docx 7.8.2 → 8.0.1

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

@@ -1,156 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-import { HorizontalPositionAlign, VerticalPositionAlign } from "@file/shared";
-
-import { FrameAnchorType, FrameProperties } from "./frame-properties";
-
-describe("FrameProperties", () => {
-    describe("#constructor()", () => {
-        it("should create", () => {
-            const currentFrameProperties = new FrameProperties({
-                position: {
-                    x: 1000,
-                    y: 3000,
-                },
-                width: 4000,
-                height: 1000,
-                anchor: {
-                    horizontal: FrameAnchorType.MARGIN,
-                    vertical: FrameAnchorType.MARGIN,
-                },
-                alignment: {
-                    x: HorizontalPositionAlign.CENTER,
-                    y: VerticalPositionAlign.TOP,
-                },
-            });
-
-            const tree = new Formatter().format(currentFrameProperties);
-            expect(tree).to.deep.equal({
-                "w:framePr": {
-                    _attr: {
-                        "w:h": 1000,
-                        "w:hAnchor": "margin",
-                        "w:vAnchor": "margin",
-                        "w:w": 4000,
-                        "w:x": 1000,
-                        "w:xAlign": "center",
-                        "w:y": 3000,
-                        "w:yAlign": "top",
-                    },
-                },
-            });
-        });
-
-        it("should create with the space attribute", () => {
-            const currentFrameProperties = new FrameProperties({
-                position: {
-                    x: 1000,
-                    y: 3000,
-                },
-                width: 4000,
-                height: 1000,
-                anchor: {
-                    horizontal: FrameAnchorType.MARGIN,
-                    vertical: FrameAnchorType.MARGIN,
-                },
-                alignment: {
-                    x: HorizontalPositionAlign.CENTER,
-                    y: VerticalPositionAlign.TOP,
-                },
-                space: {
-                    horizontal: 100,
-                    vertical: 200,
-                },
-            });
-
-            const tree = new Formatter().format(currentFrameProperties);
-            expect(tree).to.deep.equal({
-                "w:framePr": {
-                    _attr: {
-                        "w:h": 1000,
-                        "w:hAnchor": "margin",
-                        "w:vAnchor": "margin",
-                        "w:w": 4000,
-                        "w:x": 1000,
-                        "w:xAlign": "center",
-                        "w:y": 3000,
-                        "w:yAlign": "top",
-                        "w:hSpace": 100,
-                        "w:vSpace": 200,
-                    },
-                },
-            });
-        });
-
-        it("should create without x and y", () => {
-            const currentFrameProperties = new FrameProperties({
-                width: 4000,
-                height: 1000,
-                anchor: {
-                    horizontal: FrameAnchorType.MARGIN,
-                    vertical: FrameAnchorType.MARGIN,
-                },
-                alignment: {
-                    x: HorizontalPositionAlign.CENTER,
-                    y: VerticalPositionAlign.TOP,
-                },
-                space: {
-                    horizontal: 100,
-                    vertical: 200,
-                },
-            });
-
-            const tree = new Formatter().format(currentFrameProperties);
-            expect(tree).to.deep.equal({
-                "w:framePr": {
-                    _attr: {
-                        "w:h": 1000,
-                        "w:hAnchor": "margin",
-                        "w:vAnchor": "margin",
-                        "w:w": 4000,
-                        "w:xAlign": "center",
-                        "w:yAlign": "top",
-                        "w:hSpace": 100,
-                        "w:vSpace": 200,
-                    },
-                },
-            });
-        });
-
-        it("should create without alignments", () => {
-            const currentFrameProperties = new FrameProperties({
-                position: {
-                    x: 1000,
-                    y: 3000,
-                },
-                width: 4000,
-                height: 1000,
-                anchor: {
-                    horizontal: FrameAnchorType.MARGIN,
-                    vertical: FrameAnchorType.MARGIN,
-                },
-                space: {
-                    horizontal: 100,
-                    vertical: 200,
-                },
-            });
-
-            const tree = new Formatter().format(currentFrameProperties);
-            expect(tree).to.deep.equal({
-                "w:framePr": {
-                    _attr: {
-                        "w:h": 1000,
-                        "w:hAnchor": "margin",
-                        "w:vAnchor": "margin",
-                        "w:w": 4000,
-                        "w:x": 1000,
-                        "w:y": 3000,
-                        "w:hSpace": 100,
-                        "w:vSpace": 200,
-                    },
-                },
-            });
-        });
-    });
-});

package/src/file/paragraph/frame/frame-properties.ts

@@ -1,122 +0,0 @@
-// http://officeopenxml.com/WPparagraph-textFrames.php
-import { HorizontalPositionAlign, VerticalPositionAlign } from "@file/shared/alignment";
-import { HeightRule } from "@file/table";
-import { XmlAttributeComponent, XmlComponent } from "@file/xml-components";
-
-export enum DropCapType {
-    NONE = "none",
-    DROP = "drop",
-    MARGIN = "margin",
-}
-
-export enum FrameAnchorType {
-    MARGIN = "margin",
-    PAGE = "page",
-    TEXT = "text",
-}
-
-export enum FrameWrap {
-    AROUND = "around",
-    AUTO = "auto",
-    NONE = "none",
-    NOT_BESIDE = "notBeside",
-    THROUGH = "through",
-    TIGHT = "tight",
-}
-
-interface IBaseFrameOptions {
-    readonly anchorLock?: boolean;
-    readonly dropCap?: DropCapType;
-    readonly width: number;
-    readonly height: number;
-    readonly wrap?: FrameWrap;
-    readonly lines?: number;
-    readonly anchor: {
-        readonly horizontal: FrameAnchorType;
-        readonly vertical: FrameAnchorType;
-    };
-    readonly space?: {
-        readonly horizontal: number;
-        readonly vertical: number;
-    };
-    readonly rule?: HeightRule;
-}
-
-export interface IXYFrameOptions extends IBaseFrameOptions {
-    readonly position: {
-        readonly x: number;
-        readonly y: number;
-    };
-}
-
-export interface IAlignmentFrameOptions extends IBaseFrameOptions {
-    readonly alignment: {
-        readonly x: HorizontalPositionAlign;
-        readonly y: VerticalPositionAlign;
-    };
-}
-
-// Be wary of Typescript's Open types:
-// https://stackoverflow.com/q/46370222/3481582
-export type IFrameOptions = IXYFrameOptions | IAlignmentFrameOptions;
-
-export class FramePropertiesAttributes extends XmlAttributeComponent<{
-    readonly anchorLock?: boolean;
-    readonly dropCap?: DropCapType;
-    readonly width: number;
-    readonly height: number;
-    readonly x?: number;
-    readonly y?: number;
-    readonly wrap?: FrameWrap;
-    readonly lines?: number;
-    readonly anchorHorizontal?: FrameAnchorType;
-    readonly anchorVertical?: FrameAnchorType;
-    readonly spaceHorizontal?: number;
-    readonly spaceVertical?: number;
-    readonly rule?: HeightRule;
-    readonly alignmentX?: HorizontalPositionAlign;
-    readonly alignmentY?: VerticalPositionAlign;
-}> {
-    protected readonly xmlKeys = {
-        anchorLock: "w:anchorLock",
-        dropCap: "w:dropCap",
-        width: "w:w",
-        height: "w:h",
-        x: "w:x",
-        y: "w:y",
-        anchorHorizontal: "w:hAnchor",
-        anchorVertical: "w:vAnchor",
-        spaceHorizontal: "w:hSpace",
-        spaceVertical: "w:vSpace",
-        rule: "w:hRule",
-        alignmentX: "w:xAlign",
-        alignmentY: "w:yAlign",
-        lines: "w:lines",
-        wrap: "w:wrap",
-    };
-}
-
-export class FrameProperties extends XmlComponent {
-    public constructor(options: IFrameOptions) {
-        super("w:framePr");
-        this.root.push(
-            new FramePropertiesAttributes({
-                anchorLock: options.anchorLock,
-                dropCap: options.dropCap,
-                width: options.width,
-                height: options.height,
-                x: (options as IXYFrameOptions).position ? (options as IXYFrameOptions).position.x : undefined,
-                y: (options as IXYFrameOptions).position ? (options as IXYFrameOptions).position.y : undefined,
-                anchorHorizontal: options.anchor.horizontal,
-                anchorVertical: options.anchor.vertical,
-                spaceHorizontal: options.space?.horizontal,
-                spaceVertical: options.space?.vertical,
-                rule: options.rule,
-                alignmentX: (options as IAlignmentFrameOptions).alignment ? (options as IAlignmentFrameOptions).alignment.x : undefined,
-                alignmentY: (options as IAlignmentFrameOptions).alignment ? (options as IAlignmentFrameOptions).alignment.y : undefined,
-                lines: options.lines,
-                wrap: options.wrap,
-            }),
-        );
-    }
-}

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

@@ -1 +0,0 @@
-export * from "./frame-properties";

package/src/file/paragraph/index.ts

@@ -1,7 +0,0 @@
-export * from "./formatting";
-export * from "./paragraph";
-export * from "./properties";
-export * from "./run";
-export * from "./links";
-export * from "./math";
-export * from "./frame";

package/src/file/paragraph/links/bookmark-attributes.ts

@@ -1,19 +0,0 @@
-import { XmlAttributeComponent } from "@file/xml-components";
-
-export class BookmarkStartAttributes extends XmlAttributeComponent<{
-    readonly id: number;
-    readonly name: string;
-}> {
-    protected readonly xmlKeys = {
-        id: "w:id",
-        name: "w:name",
-    };
-}
-
-export class BookmarkEndAttributes extends XmlAttributeComponent<{
-    readonly id: number;
-}> {
-    protected readonly xmlKeys = {
-        id: "w:id",
-    };
-}

package/src/file/paragraph/links/bookmark.spec.ts

@@ -1,41 +0,0 @@
-import { assert, expect } from "chai";
-
-import { Utility } from "tests/utility";
-
-import { TextRun } from "../run";
-import { Bookmark } from "./bookmark";
-
-describe("Bookmark", () => {
-    let bookmark: Bookmark;
-
-    beforeEach(() => {
-        bookmark = new Bookmark({
-            id: "anchor",
-            children: [new TextRun("Internal Link")],
-        });
-    });
-
-    it("should create a bookmark with three root elements", () => {
-        const newJson = Utility.jsonify(bookmark);
-        assert.equal(newJson.rootKey, undefined);
-        assert.equal(newJson.start.rootKey, "w:bookmarkStart");
-        assert.equal(newJson.children[0].rootKey, "w:r");
-        assert.equal(newJson.end.rootKey, "w:bookmarkEnd");
-    });
-
-    it("should create a bookmark with the correct attributes on the bookmark start element", () => {
-        const newJson = Utility.jsonify(bookmark);
-
-        assert.equal(newJson.start.root[0].root.name, "anchor");
-    });
-
-    it("should create a bookmark with the correct attributes on the text element", () => {
-        const newJson = Utility.jsonify(bookmark);
-        assert.equal(JSON.stringify(newJson.children[0].root[1].root[1]), JSON.stringify("Internal Link"));
-    });
-
-    it("should create a bookmark with the correct attributes on the bookmark end element", () => {
-        const newJson = Utility.jsonify(bookmark);
-        expect(newJson.end.root[0].root.id).to.be.a("number");
-    });
-});

package/src/file/paragraph/links/bookmark.ts

@@ -1,75 +0,0 @@
-// http://officeopenxml.com/WPbookmark.php
-import { XmlComponent } from "@file/xml-components";
-import { uniqueNumericId } from "@util/convenience-functions";
-
-import { ParagraphChild } from "../paragraph";
-import { BookmarkEndAttributes, BookmarkStartAttributes } from "./bookmark-attributes";
-
-export class Bookmark {
-    public readonly start: BookmarkStart;
-    public readonly children: readonly ParagraphChild[];
-    public readonly end: BookmarkEnd;
-
-    public constructor(options: { readonly id: string; readonly children: readonly ParagraphChild[] }) {
-        const linkId = uniqueNumericId();
-
-        this.start = new BookmarkStart(options.id, linkId);
-        this.children = options.children;
-        this.end = new BookmarkEnd(linkId);
-    }
-}
-
-// <xsd:element name="bookmarkStart" type="CT_Bookmark"/>
-// <xsd:element name="bookmarkEnd" type="CT_MarkupRange"/>
-
-// <xsd:complexType name="CT_Bookmark">
-//   <xsd:complexContent>
-//     <xsd:extension base="CT_BookmarkRange">
-//     <xsd:attribute name="name" type="s:ST_String" use="required"/>
-//     </xsd:extension>
-//   </xsd:complexContent>
-// </xsd:complexType>
-
-// <xsd:complexType name="CT_BookmarkRange">
-//   <xsd:complexContent>
-//     <xsd:extension base="CT_MarkupRange">
-//       <xsd:attribute name="colFirst" type="ST_DecimalNumber" use="optional"/>
-//       <xsd:attribute name="colLast" type="ST_DecimalNumber" use="optional"/>
-//     </xsd:extension>
-//   </xsd:complexContent>
-// </xsd:complexType>
-
-// <xsd:complexType name="CT_MarkupRange">
-//   <xsd:complexContent>
-//     <xsd:extension base="CT_Markup">
-//       <xsd:attribute name="displacedByCustomXml" type="ST_DisplacedByCustomXml" use="optional"/>
-//     </xsd:extension>
-//   </xsd:complexContent>
-// </xsd:complexType>
-
-// <xsd:complexType name="CT_Markup">
-//   <xsd:attribute name="id" type="ST_DecimalNumber" use="required"/>
-// </xsd:complexType>
-
-export class BookmarkStart extends XmlComponent {
-    public constructor(id: string, linkId: number) {
-        super("w:bookmarkStart");
-
-        const attributes = new BookmarkStartAttributes({
-            name: id,
-            id: linkId,
-        });
-        this.root.push(attributes);
-    }
-}
-
-export class BookmarkEnd extends XmlComponent {
-    public constructor(linkId: number) {
-        super("w:bookmarkEnd");
-
-        const attributes = new BookmarkEndAttributes({
-            id: linkId,
-        });
-        this.root.push(attributes);
-    }
-}

package/src/file/paragraph/links/hyperlink-attributes.ts

@@ -1,15 +0,0 @@
-import { XmlAttributeComponent } from "@file/xml-components";
-
-export interface IHyperlinkAttributesProperties {
-    readonly id?: string;
-    readonly anchor?: string;
-    readonly history: number;
-}
-
-export class HyperlinkAttributes extends XmlAttributeComponent<IHyperlinkAttributesProperties> {
-    protected readonly xmlKeys = {
-        id: "r:id",
-        history: "w:history",
-        anchor: "w:anchor",
-    };
-}

package/src/file/paragraph/links/hyperlink.spec.ts

@@ -1,130 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { TextRun } from "../run";
-import { ConcreteHyperlink, ExternalHyperlink, InternalHyperlink } from "./hyperlink";
-
-describe("ConcreteHyperlink", () => {
-    let hyperlink: ConcreteHyperlink;
-
-    beforeEach(() => {
-        hyperlink = new ConcreteHyperlink(
-            [
-                new TextRun({
-                    text: "https://example.com",
-                    style: "Hyperlink",
-                }),
-            ],
-            "superid",
-        );
-    });
-
-    describe("#constructor()", () => {
-        it("should create a hyperlink with correct root key", () => {
-            const tree = new Formatter().format(hyperlink);
-            expect(tree).to.deep.equal({
-                "w:hyperlink": [
-                    {
-                        _attr: {
-                            "w:history": 1,
-                            "r:id": "rIdsuperid",
-                        },
-                    },
-                    {
-                        "w:r": [
-                            { "w:rPr": [{ "w:rStyle": { _attr: { "w:val": "Hyperlink" } } }] },
-                            { "w:t": [{ _attr: { "xml:space": "preserve" } }, "https://example.com"] },
-                        ],
-                    },
-                ],
-            });
-        });
-
-        describe("with optional anchor parameter", () => {
-            beforeEach(() => {
-                hyperlink = new ConcreteHyperlink(
-                    [
-                        new TextRun({
-                            text: "Anchor Text",
-                            style: "Hyperlink",
-                        }),
-                    ],
-                    "superid2",
-                    "anchor",
-                );
-            });
-
-            it("should create an internal link with anchor tag", () => {
-                const tree = new Formatter().format(hyperlink);
-                expect(tree).to.deep.equal({
-                    "w:hyperlink": [
-                        {
-                            _attr: {
-                                "w:history": 1,
-                                "w:anchor": "anchor",
-                            },
-                        },
-                        {
-                            "w:r": [
-                                { "w:rPr": [{ "w:rStyle": { _attr: { "w:val": "Hyperlink" } } }] },
-                                { "w:t": [{ _attr: { "xml:space": "preserve" } }, "Anchor Text"] },
-                            ],
-                        },
-                    ],
-                });
-            });
-        });
-    });
-});
-
-describe("ExternalHyperlink", () => {
-    describe("#constructor()", () => {
-        it("should create", () => {
-            const externalHyperlink = new ExternalHyperlink({
-                children: [new TextRun("test")],
-                link: "http://www.google.com",
-            });
-
-            expect(externalHyperlink.options.link).to.equal("http://www.google.com");
-        });
-    });
-});
-
-describe("InternalHyperlink", () => {
-    describe("#constructor()", () => {
-        it("should create", () => {
-            const internalHyperlink = new InternalHyperlink({
-                children: [new TextRun("test")],
-                anchor: "test-id",
-            });
-
-            const tree = new Formatter().format(internalHyperlink);
-
-            expect(tree).to.deep.equal({
-                "w:hyperlink": [
-                    {
-                        _attr: {
-                            "w:anchor": "test-id",
-                            "w:history": 1,
-                        },
-                    },
-                    {
-                        "w:r": [
-                            {
-                                "w:t": [
-                                    {
-                                        _attr: {
-                                            "xml:space": "preserve",
-                                        },
-                                    },
-                                    "test",
-                                ],
-                            },
-                        ],
-                    },
-                ],
-            });
-        });
-    });
-});

package/src/file/paragraph/links/hyperlink.ts

@@ -1,45 +0,0 @@
-// http://officeopenxml.com/WPhyperlink.php
-import { XmlComponent } from "@file/xml-components";
-import { uniqueId } from "@util/convenience-functions";
-
-import { ParagraphChild } from "../paragraph";
-import { HyperlinkAttributes, IHyperlinkAttributesProperties } from "./hyperlink-attributes";
-
-export enum HyperlinkType {
-    INTERNAL = "INTERNAL",
-    EXTERNAL = "EXTERNAL",
-}
-
-export class ConcreteHyperlink extends XmlComponent {
-    public readonly linkId: string;
-
-    public constructor(children: readonly ParagraphChild[], relationshipId: string, anchor?: string) {
-        super("w:hyperlink");
-
-        this.linkId = relationshipId;
-
-        const props: IHyperlinkAttributesProperties = {
-            history: 1,
-            anchor: anchor ? anchor : undefined,
-            id: !anchor ? `rId${this.linkId}` : undefined,
-        };
-
-        const attributes = new HyperlinkAttributes(props);
-        this.root.push(attributes);
-        children.forEach((child) => {
-            this.root.push(child);
-        });
-    }
-}
-
-export class InternalHyperlink extends ConcreteHyperlink {
-    public constructor(options: { readonly children: readonly ParagraphChild[]; readonly anchor: string }) {
-        super(options.children, uniqueId(), options.anchor);
-    }
-}
-
-export class ExternalHyperlink extends XmlComponent {
-    public constructor(public readonly options: { readonly children: readonly ParagraphChild[]; readonly link: string }) {
-        super("w:externalHyperlink");
-    }
-}

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

@@ -1,4 +0,0 @@
-export * from "./hyperlink";
-export * from "./bookmark";
-export * from "./outline-level";
-export * from "./pageref";

package/src/file/paragraph/links/outline-level.spec.ts

@@ -1,23 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { OutlineLevel } from "./outline-level";
-
-describe("ParagraphOutlineLevel", () => {
-    let outlineLevel: OutlineLevel;
-
-    describe("#constructor()", () => {
-        it("should create an outlineLevel with given value", () => {
-            outlineLevel = new OutlineLevel(0);
-            const tree = new Formatter().format(outlineLevel);
-            expect(tree).to.deep.equal({
-                "w:outlineLvl": {
-                    _attr: {
-                        "w:val": 0,
-                    },
-                },
-            });
-        });
-    });
-});

package/src/file/paragraph/links/outline-level.ts

@@ -1,14 +0,0 @@
-// http://officeopenxml.com/WPparagraph.php
-import { Attributes, XmlComponent } from "@file/xml-components";
-
-export class OutlineLevel extends XmlComponent {
-    public constructor(public readonly level: number) {
-        super("w:outlineLvl");
-
-        this.root.push(
-            new Attributes({
-                val: level,
-            }),
-        );
-    }
-}