docx 7.8.1 → 8.0.0

package/src/file/paragraph/paragraph.ts

@@ -1,7 +1,8 @@
 // http://officeopenxml.com/WPparagraph.php
 import { FootnoteReferenceRun } from "@file/footnotes";
-import { IContext, IXmlableObject, XmlComponent } from "@file/xml-components";
+import { IContext, IXmlableObject } from "@file/xml-components";
 import { uniqueId } from "@util/convenience-functions";
+import { FileChild } from "@file/file-child";
 
 import { TargetModeType } from "../relationships/relationship/relationship";
 import { DeletedTextRun, InsertedTextRun } from "../track-revision";
@@ -39,7 +40,7 @@ export interface IParagraphOptions extends IParagraphPropertiesOptions {
     readonly children?: readonly ParagraphChild[];
 }
 
-export class Paragraph extends XmlComponent {
+export class Paragraph extends FileChild {
     private readonly properties: ParagraphProperties;
 
     public constructor(options: string | IParagraphOptions) {

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

@@ -31,6 +31,7 @@ describe("ParagraphProperties", () => {
                 } as File,
                 // tslint:disable-next-line: no-object-literal-type-assertion
                 viewWrapper: new DocumentWrapper({ background: {} }),
+                stack: [],
             });
 
             expect(tree).to.deep.equal({
@@ -124,6 +125,21 @@ describe("ParagraphProperties", () => {
             });
         });
 
+        it("should create with the autoSpaceEastAsianText property", () => {
+            const properties = new ParagraphProperties({
+                autoSpaceEastAsianText: true,
+            });
+            const tree = new Formatter().format(properties);
+
+            expect(tree).to.deep.equal({
+                "w:pPr": [
+                    {
+                        "w:autoSpaceDN": {},
+                    },
+                ],
+            });
+        });
+
         it("should create with the wordWrap property", () => {
             const properties = new ParagraphProperties({
                 wordWrap: true,

package/src/file/paragraph/properties.ts

@@ -53,6 +53,11 @@ export interface IParagraphPropertiesOptions extends IParagraphStylePropertiesOp
     readonly suppressLineNumbers?: boolean;
     readonly wordWrap?: boolean;
     readonly scale?: number;
+    /**
+     * This element specifies whether inter-character spacing shall automatically be adjusted between regions of numbers and regions of East Asian text in the current paragraph. These regions shall be determined by the Unicode character values of the text content within the paragraph.
+     * This only works in Microsoft Word. It is not part of the ECMA-376 OOXML standard.
+     */
+    readonly autoSpaceEastAsianText?: boolean;
 }
 
 export class ParagraphProperties extends IgnoreIfEmptyXmlComponent {
@@ -179,6 +184,10 @@ export class ParagraphProperties extends IgnoreIfEmptyXmlComponent {
         if (options.suppressLineNumbers !== undefined) {
             this.push(new OnOffElement("w:suppressLineNumbers", options.suppressLineNumbers));
         }
+
+        if (options.autoSpaceEastAsianText !== undefined) {
+            this.push(new OnOffElement("w:autoSpaceDN", options.autoSpaceEastAsianText));
+        }
     }
 
     public push(item: XmlComponent): void {

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

@@ -2,6 +2,8 @@ import { expect } from "chai";
 import * as sinon from "sinon";
 
 import { Formatter } from "@export/formatter";
+
+import { Paragraph } from "../paragraph";
 import { Comment, CommentRangeEnd, CommentRangeStart, CommentReference, Comments } from "./comment-run";
 
 describe("CommentRangeStart", () => {
@@ -44,7 +46,7 @@ describe("Comment", () => {
     let clock: sinon.SinonFakeTimers;
 
     beforeEach(() => {
-        const now = new Date(1999, 0, 1);
+        const now = new Date("1999-01-01T00:00:00.000Z");
         clock = sinon.useFakeTimers(now.getTime());
     });
 
@@ -56,8 +58,8 @@ describe("Comment", () => {
         it("should create", () => {
             const component = new Comment({
                 id: 0,
-                text: "test-comment",
-                date: new Date(1999, 0, 1),
+                children: [new Paragraph("test-comment")],
+                date: new Date("1999-01-01T00:00:00.000Z"),
             });
             const tree = new Formatter().format(component);
             expect(tree).to.deep.equal({
@@ -88,7 +90,7 @@ describe("Comment", () => {
         it("should create by using default date", () => {
             const component = new Comment({
                 id: 0,
-                text: "test-comment",
+                children: [new Paragraph("test-comment")],
             });
             const tree = new Formatter().format(component);
             expect(tree).to.deep.equal({
@@ -125,13 +127,13 @@ describe("Comments", () => {
                 children: [
                     {
                         id: 0,
-                        text: "test-comment",
-                        date: new Date(1999, 0, 1),
+                        children: [new Paragraph("test-comment")],
+                        date: new Date("1999-01-01T00:00:00.000Z"),
                     },
                     {
                         id: 1,
-                        text: "test-comment-2",
-                        date: new Date(1999, 0, 1),
+                        children: [new Paragraph("test-comment-2")],
+                        date: new Date("1999-01-01T00:00:00.000Z"),
                     },
                 ],
             });

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

@@ -1,11 +1,9 @@
-import { Paragraph } from "@file/paragraph";
+import { FileChild } from "@file/file-child";
 import { XmlAttributeComponent, XmlComponent } from "@file/xml-components";
 
-import { TextRun } from "./text-run";
-
 export interface ICommentOptions {
     readonly id: number;
-    readonly text: string;
+    readonly children: readonly FileChild[];
     readonly initials?: string;
     readonly author?: string;
     readonly date?: Date;
@@ -120,7 +118,7 @@ export class CommentReference extends XmlComponent {
 }
 
 export class Comment extends XmlComponent {
-    public constructor({ id, initials, author, date = new Date(), text }: ICommentOptions) {
+    public constructor({ id, initials, author, date = new Date(), children }: ICommentOptions) {
         super("w:comment");
 
         this.root.push(
@@ -132,7 +130,9 @@ export class Comment extends XmlComponent {
             }),
         );
 
-        this.root.push(new Paragraph({ children: [new TextRun(text)] }));
+        for (const child of children) {
+            this.root.push(child);
+        }
     }
 }
 export class Comments extends XmlComponent {

package/src/file/paragraph/run/empty-children.spec.ts

@@ -0,0 +1,229 @@
+import { expect } from "chai";
+
+import { Formatter } from "@export/formatter";
+import {
+    AnnotationReference,
+    CarriageReturn,
+    ContinuationSeparator,
+    DayLong,
+    DayShort,
+    EndnoteReference,
+    FootnoteReferenceElement,
+    LastRenderedPageBreak,
+    MonthLong,
+    MonthShort,
+    NoBreakHyphen,
+    PageNumberElement,
+    Separator,
+    SoftHyphen,
+    Tab,
+    YearLong,
+    YearShort,
+} from "./empty-children";
+
+//         <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="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="lastRenderedPageBreak" type="CT_Empty" minOccurs="0" maxOccurs="1" />
+
+describe("NoBreakHyphen", () => {
+    describe("#constructor()", () => {
+        it("should create a NoBreakHyphen with correct root key", () => {
+            const tree = new Formatter().format(new NoBreakHyphen());
+            expect(tree).to.deep.equal({
+                "w:noBreakHyphen": {},
+            });
+        });
+    });
+});
+
+describe("SoftHyphen", () => {
+    describe("#constructor()", () => {
+        it("should create a SoftHyphen with correct root key", () => {
+            const tree = new Formatter().format(new SoftHyphen());
+            expect(tree).to.deep.equal({
+                "w:softHyphen": {},
+            });
+        });
+    });
+});
+
+describe("DayShort", () => {
+    describe("#constructor()", () => {
+        it("should create a DayShort with correct root key", () => {
+            const tree = new Formatter().format(new DayShort());
+            expect(tree).to.deep.equal({
+                "w:dayShort": {},
+            });
+        });
+    });
+});
+
+describe("MonthShort", () => {
+    describe("#constructor()", () => {
+        it("should create a MonthShort with correct root key", () => {
+            const tree = new Formatter().format(new MonthShort());
+            expect(tree).to.deep.equal({
+                "w:monthShort": {},
+            });
+        });
+    });
+});
+
+describe("YearShort", () => {
+    describe("#constructor()", () => {
+        it("should create a YearShort with correct root key", () => {
+            const tree = new Formatter().format(new YearShort());
+            expect(tree).to.deep.equal({
+                "w:yearShort": {},
+            });
+        });
+    });
+});
+
+describe("DayLong", () => {
+    describe("#constructor()", () => {
+        it("should create a DayLong with correct root key", () => {
+            const tree = new Formatter().format(new DayLong());
+            expect(tree).to.deep.equal({
+                "w:dayLong": {},
+            });
+        });
+    });
+});
+
+describe("MonthLong", () => {
+    describe("#constructor()", () => {
+        it("should create a MonthLong with correct root key", () => {
+            const tree = new Formatter().format(new MonthLong());
+            expect(tree).to.deep.equal({
+                "w:monthLong": {},
+            });
+        });
+    });
+});
+
+describe("YearLong", () => {
+    describe("#constructor()", () => {
+        it("should create a YearLong with correct root key", () => {
+            const tree = new Formatter().format(new YearLong());
+            expect(tree).to.deep.equal({
+                "w:yearLong": {},
+            });
+        });
+    });
+});
+
+describe("AnnotationReference", () => {
+    describe("#constructor()", () => {
+        it("should create a AnnotationReference with correct root key", () => {
+            const tree = new Formatter().format(new AnnotationReference());
+            expect(tree).to.deep.equal({
+                "w:annotationRef": {},
+            });
+        });
+    });
+});
+
+describe("FootnoteReferenceElement", () => {
+    describe("#constructor()", () => {
+        it("should create a FootnoteReferenceElement with correct root key", () => {
+            const tree = new Formatter().format(new FootnoteReferenceElement());
+            expect(tree).to.deep.equal({
+                "w:footnoteRef": {},
+            });
+        });
+    });
+});
+
+describe("EndnoteReference", () => {
+    describe("#constructor()", () => {
+        it("should create a EndnoteReference with correct root key", () => {
+            const tree = new Formatter().format(new EndnoteReference());
+            expect(tree).to.deep.equal({
+                "w:endnoteRef": {},
+            });
+        });
+    });
+});
+
+describe("Separator", () => {
+    describe("#constructor()", () => {
+        it("should create a Separator with correct root key", () => {
+            const tree = new Formatter().format(new Separator());
+            expect(tree).to.deep.equal({
+                "w:separator": {},
+            });
+        });
+    });
+});
+
+describe("ContinuationSeparator", () => {
+    describe("#constructor()", () => {
+        it("should create a ContinuationSeparator with correct root key", () => {
+            const tree = new Formatter().format(new ContinuationSeparator());
+            expect(tree).to.deep.equal({
+                "w:continuationSeparator": {},
+            });
+        });
+    });
+});
+
+describe("PageNumberElement", () => {
+    describe("#constructor()", () => {
+        it("should create a PageNumberElement with correct root key", () => {
+            const tree = new Formatter().format(new PageNumberElement());
+            expect(tree).to.deep.equal({
+                "w:pgNum": {},
+            });
+        });
+    });
+});
+
+describe("CarriageReturn", () => {
+    describe("#constructor()", () => {
+        it("should create a CarriageReturn with correct root key", () => {
+            const tree = new Formatter().format(new CarriageReturn());
+            expect(tree).to.deep.equal({
+                "w:cr": {},
+            });
+        });
+    });
+});
+
+describe("Tab", () => {
+    describe("#constructor()", () => {
+        it("should create a Tab with correct root key", () => {
+            const tree = new Formatter().format(new Tab());
+            expect(tree).to.deep.equal({
+                "w:tab": {},
+            });
+        });
+    });
+});
+
+describe("LastRenderedPageBreak", () => {
+    describe("#constructor()", () => {
+        it("should create a LastRenderedPageBreak with correct root key", () => {
+            const tree = new Formatter().format(new LastRenderedPageBreak());
+            expect(tree).to.deep.equal({
+                "w:lastRenderedPageBreak": {},
+            });
+        });
+    });
+});

package/src/file/paragraph/run/empty-children.ts

@@ -0,0 +1,127 @@
+import { EmptyElement } from "@file/xml-components";
+
+// <xsd:group name="EG_RunInnerContent">
+//         ...
+//         <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="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="lastRenderedPageBreak" type="CT_Empty" minOccurs="0" maxOccurs="1" />
+//     </xsd:choice>
+// </xsd:group>
+
+export class NoBreakHyphen extends EmptyElement {
+    public constructor() {
+        super("w:noBreakHyphen");
+    }
+}
+
+export class SoftHyphen extends EmptyElement {
+    public constructor() {
+        super("w:softHyphen");
+    }
+}
+
+export class DayShort extends EmptyElement {
+    public constructor() {
+        super("w:dayShort");
+    }
+}
+
+export class MonthShort extends EmptyElement {
+    public constructor() {
+        super("w:monthShort");
+    }
+}
+
+export class YearShort extends EmptyElement {
+    public constructor() {
+        super("w:yearShort");
+    }
+}
+
+export class DayLong extends EmptyElement {
+    public constructor() {
+        super("w:dayLong");
+    }
+}
+
+export class MonthLong extends EmptyElement {
+    public constructor() {
+        super("w:monthLong");
+    }
+}
+
+export class YearLong extends EmptyElement {
+    public constructor() {
+        super("w:yearLong");
+    }
+}
+
+export class AnnotationReference extends EmptyElement {
+    public constructor() {
+        super("w:annotationRef");
+    }
+}
+
+export class FootnoteReferenceElement extends EmptyElement {
+    public constructor() {
+        super("w:footnoteRef");
+    }
+}
+
+export class EndnoteReference extends EmptyElement {
+    public constructor() {
+        super("w:endnoteRef");
+    }
+}
+
+export class Separator extends EmptyElement {
+    public constructor() {
+        super("w:separator");
+    }
+}
+
+export class ContinuationSeparator extends EmptyElement {
+    public constructor() {
+        super("w:continuationSeparator");
+    }
+}
+
+export class PageNumberElement extends EmptyElement {
+    public constructor() {
+        super("w:pgNum");
+    }
+}
+
+export class CarriageReturn extends EmptyElement {
+    public constructor() {
+        super("w:cr");
+    }
+}
+
+export class Tab extends EmptyElement {
+    public constructor() {
+        super("w:tab");
+    }
+}
+
+export class LastRenderedPageBreak extends EmptyElement {
+    public constructor() {
+        super("w:lastRenderedPageBreak");
+    }
+}

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

@@ -1,8 +1,8 @@
 import { Attributes, XmlComponent } from "@file/xml-components";
-import { hexColorValue, signedTwipsMeasureValue } from "@util/values";
+import { hexColorValue, signedTwipsMeasureValue, UniversalMeasure } from "@util/values";
 
 export class CharacterSpacing extends XmlComponent {
-    public constructor(value: number | string) {
+    public constructor(value: number | UniversalMeasure) {
         super("w:spacing");
         this.root.push(
             new Attributes({

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

@@ -47,6 +47,7 @@ describe("ImageRun", () => {
                     },
                 } as unknown as File,
                 viewWrapper: {} as unknown as IViewWrapper,
+                stack: [],
             });
             expect(tree).to.deep.equal({
                 "w:r": [
@@ -298,6 +299,7 @@ describe("ImageRun", () => {
                     },
                 } as unknown as File,
                 viewWrapper: {} as unknown as IViewWrapper,
+                stack: [],
             });
             expect(tree).to.deep.equal({
                 "w:r": [
@@ -552,6 +554,7 @@ describe("ImageRun", () => {
                     },
                 } as unknown as File,
                 viewWrapper: {} as unknown as IViewWrapper,
+                stack: [],
             });
 
             expect(tree).to.deep.equal({
@@ -810,6 +813,7 @@ describe("ImageRun", () => {
                     },
                 } as unknown as File,
                 viewWrapper: {} as unknown as IViewWrapper,
+                stack: [],
             });
 
             expect(tree).to.deep.equal({

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

@@ -7,6 +7,7 @@ export * from "./run-fonts";
 export * from "./sequential-identifier";
 export * from "./underline";
 export * from "./emphasis-mark";
-export * from "./tab";
 export * from "./simple-field";
 export * from "./comment-run";
+export * from "./empty-children";
+export * from "./positional-tab";

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

@@ -0,0 +1,29 @@
+import { expect } from "chai";
+
+import { Formatter } from "@export/formatter";
+
+import { createLanguageComponent } from "./language";
+
+describe("Language", () => {
+    describe("#createLanguageComponent", () => {
+        it("should create a language component", () => {
+            const tree = new Formatter().format(
+                createLanguageComponent({
+                    value: "en-US",
+                    eastAsia: "zh-CN",
+                    bidirectional: "ar-SA",
+                }),
+            );
+
+            expect(tree).to.deep.equal({
+                "w:lang": {
+                    _attr: {
+                        "w:bidi": "ar-SA",
+                        "w:eastAsia": "zh-CN",
+                        "w:val": "en-US",
+                    },
+                },
+            });
+        });
+    });
+});

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

@@ -0,0 +1,35 @@
+import { BuilderElement, XmlComponent } from "@file/xml-components";
+
+// <xsd:complexType name="CT_Language">
+//   <xsd:attribute name="val" type="s:ST_Lang" use="optional"/>
+//   <xsd:attribute name="eastAsia" type="s:ST_Lang" use="optional"/>
+//   <xsd:attribute name="bidi" type="s:ST_Lang" use="optional"/>
+// </xsd:complexType>
+export interface ILanguageOptions {
+    readonly value?: string;
+    readonly eastAsia?: string;
+    readonly bidirectional?: string;
+}
+
+export const createLanguageComponent = (options: ILanguageOptions): XmlComponent =>
+    new BuilderElement<{
+        readonly value?: string;
+        readonly eastAsia?: string;
+        readonly bidirectional?: string;
+    }>({
+        name: "w:lang",
+        attributes: {
+            value: {
+                key: "w:val",
+                value: options.value,
+            },
+            eastAsia: {
+                key: "w:eastAsia",
+                value: options.eastAsia,
+            },
+            bidirectional: {
+                key: "w:bidi",
+                value: options.bidirectional,
+            },
+        },
+    });

package/src/file/paragraph/run/positional-tab.spec.ts

@@ -0,0 +1,27 @@
+import { expect } from "chai";
+
+import { Formatter } from "@export/formatter";
+
+import { PositionalTab, PositionalTabAlignment, PositionalTabLeader, PositionalTabRelativeTo } from "./positional-tab";
+
+describe("PositionalTab", () => {
+    it("should create a PositionalTab with correct root key", () => {
+        const tree = new Formatter().format(
+            new PositionalTab({
+                alignment: PositionalTabAlignment.CENTER,
+                relativeTo: PositionalTabRelativeTo.MARGIN,
+                leader: PositionalTabLeader.DOT,
+            }),
+        );
+
+        expect(tree).to.deep.equal({
+            "w:ptab": {
+                _attr: {
+                    "w:alignment": "center",
+                    "w:relativeTo": "margin",
+                    "w:leader": "dot",
+                },
+            },
+        });
+    });
+});