docx 7.8.2 → 8.0.0

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

@@ -0,0 +1,80 @@
+import { NextAttributeComponent, XmlComponent } from "@file/xml-components";
+
+// <xsd:simpleType name="ST_PTabAlignment">
+//     <xsd:restriction base="xsd:string">
+//         <xsd:enumeration value="left" />
+//         <xsd:enumeration value="center" />
+//         <xsd:enumeration value="right" />
+//     </xsd:restriction>
+// </xsd:simpleType>
+export enum PositionalTabAlignment {
+    LEFT = "left",
+    CENTER = "center",
+    RIGHT = "right",
+}
+
+// <xsd:simpleType name="ST_PTabRelativeTo">
+//     <xsd:restriction base="xsd:string">
+//         <xsd:enumeration value="margin" />
+//         <xsd:enumeration value="indent" />
+//     </xsd:restriction>
+// </xsd:simpleType>
+export enum PositionalTabRelativeTo {
+    MARGIN = "margin",
+    INDENT = "indent",
+}
+
+// <xsd:simpleType name="ST_PTabLeader">
+//     <xsd:restriction base="xsd:string">
+//         <xsd:enumeration value="none" />
+//         <xsd:enumeration value="dot" />
+//         <xsd:enumeration value="hyphen" />
+//         <xsd:enumeration value="underscore" />
+//         <xsd:enumeration value="middleDot" />
+//     </xsd:restriction>
+// </xsd:simpleType>
+export enum PositionalTabLeader {
+    NONE = "none",
+    DOT = "dot",
+    HYPHEN = "hyphen",
+    UNDERSCORE = "underscore",
+    MIDDLE_DOT = "middleDot",
+}
+
+export interface PositionalTabOptions {
+    readonly alignment: PositionalTabAlignment;
+    readonly relativeTo: PositionalTabRelativeTo;
+    readonly leader: PositionalTabLeader;
+}
+
+// <xsd:complexType name="CT_PTab">
+//     <xsd:attribute name="alignment" type="ST_PTabAlignment" use="required" />
+//     <xsd:attribute name="relativeTo" type="ST_PTabRelativeTo" use="required" />
+//     <xsd:attribute name="leader" type="ST_PTabLeader" use="required" />
+// </xsd:complexType>
+export class PositionalTab extends XmlComponent {
+    public constructor(options: PositionalTabOptions) {
+        super("w:ptab");
+
+        this.root.push(
+            new NextAttributeComponent<{
+                readonly alignment: PositionalTabAlignment;
+                readonly relativeTo: PositionalTabRelativeTo;
+                readonly leader: PositionalTabLeader;
+            }>({
+                alignment: {
+                    key: "w:alignment",
+                    value: options.alignment,
+                },
+                relativeTo: {
+                    key: "w:relativeTo",
+                    value: options.relativeTo,
+                },
+                leader: {
+                    key: "w:leader",
+                    value: options.leader,
+                },
+            }),
+        );
+    }
+}

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

@@ -9,9 +9,11 @@ import {
     StringValueElement,
     XmlComponent,
 } from "@file/xml-components";
+import { PositiveUniversalMeasure, UniversalMeasure } from "@util/values";
 
 import { EmphasisMark, EmphasisMarkType } from "./emphasis-mark";
 import { CharacterSpacing, Color, Highlight, HighlightComplexScript } from "./formatting";
+import { createLanguageComponent, ILanguageOptions } from "./language";
 import { IFontAttributesProperties, RunFonts } from "./run-fonts";
 import { SubScript, SuperScript } from "./script";
 import { Underline, UnderlineType } from "./underline";
@@ -21,6 +23,16 @@ interface IFontOptions {
     readonly hint?: string;
 }
 
+export enum TextEffect {
+    BLINK_BACKGROUND = "blinkBackground",
+    LIGHTS = "lights",
+    ANTS_BLACK = "antsBlack",
+    ANTS_RED = "antsRed",
+    SHIMMER = "shimmer",
+    SPARKLE = "sparkle",
+    NONE = "none",
+}
+
 export interface IRunStylePropertiesOptions {
     readonly bold?: boolean;
     readonly boldComplexScript?: boolean;
@@ -30,12 +42,15 @@ export interface IRunStylePropertiesOptions {
         readonly color?: string;
         readonly type?: UnderlineType;
     };
+    readonly effect?: TextEffect;
     readonly emphasisMark?: {
         readonly type?: EmphasisMarkType;
     };
     readonly color?: string;
-    readonly size?: number | string;
-    readonly sizeComplexScript?: boolean | number | string;
+    readonly kern?: number | PositiveUniversalMeasure;
+    readonly position?: UniversalMeasure;
+    readonly size?: number | PositiveUniversalMeasure;
+    readonly sizeComplexScript?: boolean | number | PositiveUniversalMeasure;
     readonly rightToLeft?: boolean;
     readonly smallCaps?: boolean;
     readonly allCaps?: boolean;
@@ -51,10 +66,13 @@ export interface IRunStylePropertiesOptions {
     readonly emboss?: boolean;
     readonly imprint?: boolean;
     readonly revision?: IRunPropertiesChangeOptions;
+    readonly language?: ILanguageOptions;
     readonly border?: IBorderOptions;
+    readonly snapToGrid?: boolean;
     readonly vanish?: boolean;
     readonly specVanish?: boolean;
     readonly scale?: number;
+    readonly math?: boolean;
 }
 
 export interface IRunPropertiesOptions extends IRunStylePropertiesOptions {
@@ -133,6 +151,10 @@ export class RunProperties extends IgnoreIfEmptyXmlComponent {
             this.push(new Underline(options.underline.type, options.underline.color));
         }
 
+        if (options.effect) {
+            this.push(new StringValueElement("w:effect", options.effect));
+        }
+
         if (options.emphasisMark) {
             this.push(new EmphasisMark(options.emphasisMark.type));
         }
@@ -141,6 +163,14 @@ export class RunProperties extends IgnoreIfEmptyXmlComponent {
             this.push(new Color(options.color));
         }
 
+        if (options.kern) {
+            this.push(new HpsMeasureElement("w:kern", options.kern));
+        }
+
+        if (options.position) {
+            this.push(new StringValueElement("w:position", options.position));
+        }
+
         if (options.size !== undefined) {
             this.push(new HpsMeasureElement("w:sz", options.size));
         }
@@ -226,6 +256,10 @@ export class RunProperties extends IgnoreIfEmptyXmlComponent {
             this.push(new BorderElement("w:bdr", options.border));
         }
 
+        if (options.snapToGrid) {
+            this.push(new OnOffElement("w:snapToGrid", options.snapToGrid));
+        }
+
         if (options.vanish) {
             // https://c-rex.net/projects/samples/ooxml/e1/Part4/OOXML_P4_DOCX_vanish_topic_ID0E6W3O.html
             // http://www.datypic.com/sc/ooxml/e-w_vanish-1.html
@@ -240,6 +274,14 @@ export class RunProperties extends IgnoreIfEmptyXmlComponent {
         if (options.scale !== undefined) {
             this.push(new NumberValueElement("w:w", options.scale));
         }
+
+        if (options.language) {
+            this.push(createLanguageComponent(options.language));
+        }
+
+        if (options.math) {
+            this.push(new OnOffElement("w:oMath", options.math));
+        }
     }
 
     public push(item: XmlComponent): void {

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

@@ -7,6 +7,7 @@ import { ShadingType } from "@file/shading";
 import { EmphasisMarkType } from "./emphasis-mark";
 import { PageNumber, Run } from "./run";
 import { UnderlineType } from "./underline";
+import { TextEffect } from "./properties";
 
 describe("Run", () => {
     describe("#bold()", () => {
@@ -580,5 +581,147 @@ describe("Run", () => {
                 });
             });
         });
+
+        describe("#language", () => {
+            it("should correctly set the language", () => {
+                const run = new Run({
+                    language: {
+                        value: "en-US",
+                        eastAsia: "zh-CN",
+                        bidirectional: "ar-SA",
+                    },
+                });
+                const tree = new Formatter().format(run);
+                expect(tree).to.deep.equal({
+                    "w:r": [
+                        {
+                            "w:rPr": [
+                                {
+                                    "w:lang": {
+                                        _attr: {
+                                            "w:val": "en-US",
+                                            "w:eastAsia": "zh-CN",
+                                            "w:bidi": "ar-SA",
+                                        },
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                });
+            });
+        });
+
+        describe("#position", () => {
+            it("should correctly set the position", () => {
+                const run = new Run({
+                    position: "2mm",
+                });
+                const tree = new Formatter().format(run);
+                expect(tree).to.deep.equal({
+                    "w:r": [
+                        {
+                            "w:rPr": [
+                                {
+                                    "w:position": {
+                                        _attr: {
+                                            "w:val": "2mm",
+                                        },
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                });
+            });
+        });
+
+        describe("#effect", () => {
+            it("should correctly set the effect", () => {
+                const run = new Run({
+                    effect: TextEffect.ANTS_BLACK,
+                });
+                const tree = new Formatter().format(run);
+                expect(tree).to.deep.equal({
+                    "w:r": [
+                        {
+                            "w:rPr": [
+                                {
+                                    "w:effect": {
+                                        _attr: {
+                                            "w:val": "antsBlack",
+                                        },
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                });
+            });
+        });
+
+        describe("#math", () => {
+            it("should correctly set the math", () => {
+                const run = new Run({
+                    math: true,
+                });
+                const tree = new Formatter().format(run);
+                expect(tree).to.deep.equal({
+                    "w:r": [
+                        {
+                            "w:rPr": [
+                                {
+                                    "w:oMath": {},
+                                },
+                            ],
+                        },
+                    ],
+                });
+            });
+        });
+
+        describe("#kern", () => {
+            it("should correctly set the kern", () => {
+                const run = new Run({
+                    kern: "2mm",
+                });
+                const tree = new Formatter().format(run);
+                expect(tree).to.deep.equal({
+                    "w:r": [
+                        {
+                            "w:rPr": [
+                                {
+                                    "w:kern": {
+                                        _attr: {
+                                            "w:val": "2mm",
+                                        },
+                                    },
+                                },
+                            ],
+                        },
+                    ],
+                });
+            });
+        });
+
+        describe("#snapToGrid", () => {
+            it("should correctly set the snapToGrid", () => {
+                const run = new Run({
+                    snapToGrid: true,
+                });
+                const tree = new Formatter().format(run);
+                expect(tree).to.deep.equal({
+                    "w:r": [
+                        {
+                            "w:rPr": [
+                                {
+                                    "w:snapToGrid": {},
+                                },
+                            ],
+                        },
+                    ],
+                });
+            });
+        });
     });
 });

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

@@ -9,10 +9,91 @@ 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 { Tab } from "./tab";
+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 {
-    readonly children?: readonly (Begin | FieldInstruction | Separate | End | PageNumber | FootnoteReferenceRun | Tab | string)[];
+    // <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;
 }

package/src/file/relationships/relationships.ts

@@ -12,13 +12,9 @@ export class Relationships extends XmlComponent {
         );
     }
 
-    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);
+        this.root.push(relationship);
 
         return relationship;
     }

package/src/file/styles/sample/default-style.ts

@@ -1,4 +1,10 @@
-const createLsdException = (name: string, uiPriority?: number, qFormat?: number, semiHidden?: number, unhideWhenUsed?: number) => {
+const createLsdException = (
+    name: string,
+    uiPriority?: number,
+    qFormat?: number,
+    semiHidden?: number,
+    unhideWhenUsed?: number,
+): readonly object[] => {
     "use strict";
 
     return [

package/src/file/table/grid.ts

@@ -9,11 +9,11 @@
 //     </xsd:sequence>
 // </xsd:complexType>
 
-import { XmlAttributeComponent, XmlComponent } from "@file/xml-components";
-import { twipsMeasureValue } from "@util/values";
+import { NextAttributeComponent, XmlComponent } from "@file/xml-components";
+import { PositiveUniversalMeasure, twipsMeasureValue } from "@util/values";
 
 export class TableGrid extends XmlComponent {
-    public constructor(widths: readonly number[] | readonly string[]) {
+    public constructor(widths: readonly number[] | readonly PositiveUniversalMeasure[]) {
         super("w:tblGrid");
         for (const width of widths) {
             this.root.push(new GridCol(width));
@@ -21,15 +21,15 @@ export class TableGrid extends XmlComponent {
     }
 }
 
-class GridColAttributes extends XmlAttributeComponent<{ readonly w: number | string }> {
-    protected readonly xmlKeys = { w: "w:w" };
-}
-
 export class GridCol extends XmlComponent {
-    public constructor(width?: number | string) {
+    public constructor(width?: number | PositiveUniversalMeasure) {
         super("w:gridCol");
         if (width !== undefined) {
-            this.root.push(new GridColAttributes({ w: twipsMeasureValue(width) }));
+            this.root.push(
+                new NextAttributeComponent<{ readonly width: number | PositiveUniversalMeasure }>({
+                    width: { key: "w:w", value: twipsMeasureValue(width) },
+                }),
+            );
         }
     }
 }

package/src/file/table/table-properties/table-float-properties.spec.ts

@@ -38,9 +38,7 @@ describe("Table Float Properties", () => {
             expect(tree).to.deep.equal({
                 "w:tblpPr": [
                     {
-                        _attr: {
-                            overlap: "never",
-                        },
+                        _attr: {},
                     },
                     {
                         "w:tblOverlap": {