docx 8.0.0 → 8.0.1

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

@@ -1,73 +0,0 @@
-import { uniqueId } from "@util/convenience-functions";
-
-import { IContext, IXmlableObject } from "@file/xml-components";
-import { DocPropertiesOptions } from "@file/drawing/doc-properties/doc-properties";
-
-import { Drawing, IFloating } from "../../drawing";
-import { IMediaTransformation } from "../../media";
-import { IMediaData } from "../../media/data";
-import { Run } from "../run";
-
-export interface IImageOptions {
-    readonly data: Buffer | string | Uint8Array | ArrayBuffer;
-    readonly transformation: IMediaTransformation;
-    readonly floating?: IFloating;
-    readonly altText?: DocPropertiesOptions;
-}
-
-export class ImageRun extends Run {
-    private readonly key = `${uniqueId()}.png`;
-    private readonly imageData: IMediaData;
-
-    public constructor(options: IImageOptions) {
-        super({});
-        const newData = typeof options.data === "string" ? this.convertDataURIToBinary(options.data) : options.data;
-
-        this.imageData = {
-            stream: newData,
-            fileName: this.key,
-            transformation: {
-                pixels: {
-                    x: Math.round(options.transformation.width),
-                    y: Math.round(options.transformation.height),
-                },
-                emus: {
-                    x: Math.round(options.transformation.width * 9525),
-                    y: Math.round(options.transformation.height * 9525),
-                },
-                flip: options.transformation.flip,
-                rotation: options.transformation.rotation ? options.transformation.rotation * 60000 : undefined,
-            },
-        };
-        const drawing = new Drawing(this.imageData, { floating: options.floating, docProperties: options.altText });
-
-        this.root.push(drawing);
-    }
-
-    public prepForXml(context: IContext): IXmlableObject | undefined {
-        context.file.Media.addImage(this.key, this.imageData);
-
-        return super.prepForXml(context);
-    }
-
-    private convertDataURIToBinary(dataURI: string): Uint8Array {
-        if (typeof atob === "function") {
-            // https://gist.github.com/borismus/1032746
-            // https://github.com/mafintosh/base64-to-uint8array
-            const BASE64_MARKER = ";base64,";
-            const base64Index = dataURI.indexOf(BASE64_MARKER);
-
-            const base64IndexWithOffset = base64Index === -1 ? 0 : base64Index + BASE64_MARKER.length;
-
-            return new Uint8Array(
-                atob(dataURI.substring(base64IndexWithOffset))
-                    .split("")
-                    .map((c) => c.charCodeAt(0)),
-            );
-        } else {
-            // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-var-requires
-            const b = require("buf" + "fer");
-            return new b.Buffer(dataURI, "base64");
-        }
-    }
-}

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

@@ -1,13 +0,0 @@
-export * from "./run";
-export * from "./properties";
-export * from "./text-run";
-export * from "./symbol-run";
-export * from "./image-run";
-export * from "./run-fonts";
-export * from "./sequential-identifier";
-export * from "./underline";
-export * from "./emphasis-mark";
-export * from "./simple-field";
-export * from "./comment-run";
-export * from "./empty-children";
-export * from "./positional-tab";

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

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

@@ -1,35 +0,0 @@
-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/page-number.spec.ts

@@ -1,32 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { NumberOfPages, NumberOfPagesSection, Page } from "./page-number";
-
-describe("Page", () => {
-    describe("#constructor()", () => {
-        it("uses the font name for both ascii and hAnsi", () => {
-            const tree = new Formatter().format(new Page());
-            expect(tree).to.deep.equal({ "w:instrText": [{ _attr: { "xml:space": "preserve" } }, "PAGE"] });
-        });
-    });
-});
-
-describe("NumberOfPages", () => {
-    describe("#constructor()", () => {
-        it("uses the font name for both ascii and hAnsi", () => {
-            const tree = new Formatter().format(new NumberOfPages());
-            expect(tree).to.deep.equal({ "w:instrText": [{ _attr: { "xml:space": "preserve" } }, "NUMPAGES"] });
-        });
-    });
-});
-
-describe("NumberOfPagesSection", () => {
-    describe("#constructor()", () => {
-        it("uses the font name for both ascii and hAnsi", () => {
-            const tree = new Formatter().format(new NumberOfPagesSection());
-            expect(tree).to.deep.equal({ "w:instrText": [{ _attr: { "xml:space": "preserve" } }, "SECTIONPAGES"] });
-        });
-    });
-});

package/src/file/paragraph/run/page-number.ts

@@ -1,28 +0,0 @@
-import { SpaceType } from "@file/shared";
-import { XmlComponent } from "@file/xml-components";
-
-import { TextAttributes } from "./text-attributes";
-
-export class Page extends XmlComponent {
-    public constructor() {
-        super("w:instrText");
-        this.root.push(new TextAttributes({ space: SpaceType.PRESERVE }));
-        this.root.push("PAGE");
-    }
-}
-
-export class NumberOfPages extends XmlComponent {
-    public constructor() {
-        super("w:instrText");
-        this.root.push(new TextAttributes({ space: SpaceType.PRESERVE }));
-        this.root.push("NUMPAGES");
-    }
-}
-
-export class NumberOfPagesSection extends XmlComponent {
-    public constructor() {
-        super("w:instrText");
-        this.root.push(new TextAttributes({ space: SpaceType.PRESERVE }));
-        this.root.push("SECTIONPAGES");
-    }
-}

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

@@ -1,27 +0,0 @@
-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",
-                },
-            },
-        });
-    });
-});

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

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

@@ -1,304 +0,0 @@
-import { BorderElement, IBorderOptions } from "@file/border";
-import { IShadingAttributesProperties, Shading } from "@file/shading";
-import { ChangeAttributes, IChangedAttributesProperties } from "@file/track-revision/track-revision";
-import {
-    HpsMeasureElement,
-    IgnoreIfEmptyXmlComponent,
-    NumberValueElement,
-    OnOffElement,
-    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";
-
-interface IFontOptions {
-    readonly name: string;
-    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;
-    readonly italics?: boolean;
-    readonly italicsComplexScript?: boolean;
-    readonly underline?: {
-        readonly color?: string;
-        readonly type?: UnderlineType;
-    };
-    readonly effect?: TextEffect;
-    readonly emphasisMark?: {
-        readonly type?: EmphasisMarkType;
-    };
-    readonly color?: 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;
-    readonly strike?: boolean;
-    readonly doubleStrike?: boolean;
-    readonly subScript?: boolean;
-    readonly superScript?: boolean;
-    readonly font?: string | IFontOptions | IFontAttributesProperties;
-    readonly highlight?: string;
-    readonly highlightComplexScript?: boolean | string;
-    readonly characterSpacing?: number;
-    readonly shading?: IShadingAttributesProperties;
-    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 {
-    readonly style?: string;
-}
-
-export interface IRunPropertiesChangeOptions extends IRunPropertiesOptions, IChangedAttributesProperties {}
-
-// <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 {
-    public constructor(options?: IRunPropertiesOptions) {
-        super("w:rPr");
-
-        if (!options) {
-            return;
-        }
-
-        if (options.bold !== undefined) {
-            this.push(new OnOffElement("w:b", options.bold));
-        }
-        if ((options.boldComplexScript === undefined && options.bold !== undefined) || options.boldComplexScript) {
-            this.push(new OnOffElement("w:bCs", options.boldComplexScript ?? options.bold));
-        }
-
-        if (options.italics !== undefined) {
-            this.push(new OnOffElement("w:i", options.italics));
-        }
-
-        if ((options.italicsComplexScript === undefined && options.italics !== undefined) || options.italicsComplexScript) {
-            this.push(new OnOffElement("w:iCs", options.italicsComplexScript ?? options.italics));
-        }
-
-        if (options.underline) {
-            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));
-        }
-
-        if (options.color) {
-            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));
-        }
-        const szCs =
-            options.sizeComplexScript === undefined || options.sizeComplexScript === true ? options.size : options.sizeComplexScript;
-        if (szCs) {
-            this.push(new HpsMeasureElement("w:szCs", szCs));
-        }
-
-        if (options.rightToLeft !== undefined) {
-            this.push(new OnOffElement("w:rtl", options.rightToLeft));
-        }
-
-        // 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.strike !== undefined) {
-            this.push(new OnOffElement("w:strike", options.strike));
-        }
-
-        if (options.doubleStrike !== undefined) {
-            this.push(new OnOffElement("w:dstrike", options.doubleStrike));
-        }
-
-        if (options.subScript) {
-            this.push(new SubScript());
-        }
-
-        if (options.superScript) {
-            this.push(new SuperScript());
-        }
-
-        if (options.style) {
-            this.push(new StringValueElement("w:rStyle", options.style));
-        }
-
-        if (options.font) {
-            if (typeof options.font === "string") {
-                this.push(new RunFonts(options.font));
-            } else if ("name" in options.font) {
-                this.push(new RunFonts(options.font.name, options.font.hint));
-            } else {
-                this.push(new RunFonts(options.font));
-            }
-        }
-
-        if (options.highlight) {
-            this.push(new Highlight(options.highlight));
-        }
-        const highlightCs =
-            options.highlightComplexScript === undefined || options.highlightComplexScript === true
-                ? options.highlight
-                : options.highlightComplexScript;
-        if (highlightCs) {
-            this.push(new HighlightComplexScript(highlightCs));
-        }
-
-        if (options.characterSpacing) {
-            this.push(new CharacterSpacing(options.characterSpacing));
-        }
-
-        if (options.emboss !== undefined) {
-            this.push(new OnOffElement("w:emboss", options.emboss));
-        }
-
-        if (options.imprint !== undefined) {
-            this.push(new OnOffElement("w:imprint", options.imprint));
-        }
-
-        if (options.shading) {
-            this.push(new Shading(options.shading));
-        }
-
-        if (options.revision) {
-            this.push(new RunPropertiesChange(options.revision));
-        }
-
-        if (options.border) {
-            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
-            this.push(new OnOffElement("w:vanish", options.vanish));
-        }
-
-        if (options.specVanish) {
-            // https://c-rex.net/projects/samples/ooxml/e1/Part4/OOXML_P4_DOCX_specVanish_topic_ID0EIE1O.html
-            this.push(new OnOffElement("w:specVanish", options.vanish));
-        }
-
-        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 {
-        this.root.push(item);
-    }
-}
-
-export class RunPropertiesChange extends XmlComponent {
-    public constructor(options: IRunPropertiesChangeOptions) {
-        super("w:rPrChange");
-        this.root.push(
-            new ChangeAttributes({
-                id: options.id,
-                author: options.author,
-                date: options.date,
-            }),
-        );
-        this.addChildElement(new RunProperties(options as IRunPropertiesOptions));
-    }
-}

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

@@ -1,28 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { Symbol } from "./symbol";
-
-describe("Symbol", () => {
-    describe("#constructor", () => {
-        // Note: if no character is given, the output is a MS Windows logo
-        it("creates an empty symbol run if no character is given", () => {
-            const s = new Symbol();
-            const f = new Formatter().format(s);
-            expect(f).to.deep.equal({ "w:sym": { _attr: { "w:char": "", "w:font": "Wingdings" } } });
-        });
-
-        it("creates the provided symbol with default font", () => {
-            const s = new Symbol("F071");
-            const f = new Formatter().format(s);
-            expect(f).to.deep.equal({ "w:sym": { _attr: { "w:char": "F071", "w:font": "Wingdings" } } });
-        });
-
-        it("creates the provided symbol with the provided font", () => {
-            const s = new Symbol("F071", "Arial");
-            const f = new Formatter().format(s);
-            expect(f).to.deep.equal({ "w:sym": { _attr: { "w:char": "F071", "w:font": "Arial" } } });
-        });
-    });
-});

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

@@ -1,18 +0,0 @@
-import { XmlAttributeComponent, XmlComponent } from "@file/xml-components";
-
-class SymbolAttributes extends XmlAttributeComponent<{
-    readonly char: string;
-    readonly symbolfont?: string;
-}> {
-    protected readonly xmlKeys = {
-        char: "w:char",
-        symbolfont: "w:font",
-    };
-}
-
-export class Symbol extends XmlComponent {
-    public constructor(char: string = "", symbolfont: string = "Wingdings") {
-        super("w:sym");
-        this.root.push(new SymbolAttributes({ char: char, symbolfont: symbolfont }));
-    }
-}