docx 8.0.0 → 8.0.1

package/src/file/paragraph/math/function/math-function.spec.ts

@@ -1,48 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { MathRun } from "../math-run";
-import { MathFunction } from "./math-function";
-
-describe("MathFunction", () => {
-    describe("#constructor()", () => {
-        it("should create a MathFunction with correct root key", () => {
-            const mathFunction = new MathFunction({
-                name: [new MathRun("sin")],
-                children: [new MathRun("60")],
-            });
-
-            const tree = new Formatter().format(mathFunction);
-            expect(tree).to.deep.equal({
-                "m:func": [
-                    {
-                        "m:funcPr": {},
-                    },
-                    {
-                        "m:fName": [
-                            {
-                                "m:r": [
-                                    {
-                                        "m:t": ["sin"],
-                                    },
-                                ],
-                            },
-                        ],
-                    },
-                    {
-                        "m:e": [
-                            {
-                                "m:r": [
-                                    {
-                                        "m:t": ["60"],
-                                    },
-                                ],
-                            },
-                        ],
-                    },
-                ],
-            });
-        });
-    });
-});

package/src/file/paragraph/math/function/math-function.ts

@@ -1,22 +0,0 @@
-// http://www.datypic.com/sc/ooxml/e-m_func-1.html
-import { XmlComponent } from "@file/xml-components";
-
-import { MathComponent } from "../math-component";
-import { MathBase } from "../n-ary";
-import { MathFunctionName } from "./math-function-name";
-import { MathFunctionProperties } from "./math-function-properties";
-
-export interface IMathFunctionOptions {
-    readonly children: readonly MathComponent[];
-    readonly name: readonly MathComponent[];
-}
-
-export class MathFunction extends XmlComponent {
-    public constructor(options: IMathFunctionOptions) {
-        super("m:func");
-
-        this.root.push(new MathFunctionProperties());
-        this.root.push(new MathFunctionName(options.name));
-        this.root.push(new MathBase(options.children));
-    }
-}

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

@@ -1,9 +0,0 @@
-export * from "./math";
-export * from "./math-run";
-export * from "./fraction";
-export * from "./n-ary";
-export * from "./script";
-export * from "./math-component";
-export * from "./radical";
-export * from "./function";
-export * from "./brackets";

package/src/file/paragraph/math/math-component.ts

@@ -1,28 +0,0 @@
-import { MathAngledBrackets, MathCurlyBrackets, MathRoundBrackets, MathSquareBrackets } from "./brackets";
-import { MathFraction } from "./fraction";
-import { MathFunction } from "./function";
-import { MathRun } from "./math-run";
-import { MathSum, MathIntegral } from "./n-ary";
-import { MathRadical } from "./radical";
-import { MathSubScript, MathSubSuperScript, MathSuperScript } from "./script";
-
-export type MathComponent =
-    | MathRun
-    | MathFraction
-    | MathSum
-    | MathIntegral
-    | MathSuperScript
-    | MathSubScript
-    | MathSubSuperScript
-    | MathRadical
-    | MathFunction
-    | MathRoundBrackets
-    | MathCurlyBrackets
-    | MathAngledBrackets
-    | MathSquareBrackets;
-
-// Needed because of: https://github.com/s-panferov/awesome-typescript-loader/issues/432
-/**
- * @ignore
- */
-export const WORKAROUND4 = "";

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

@@ -1,21 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { MathRun } from "./math-run";
-
-describe("MathRun", () => {
-    describe("#constructor()", () => {
-        it("should create a MathRun with correct root key", () => {
-            const mathRun = new MathRun("2+2");
-            const tree = new Formatter().format(mathRun);
-            expect(tree).to.deep.equal({
-                "m:r": [
-                    {
-                        "m:t": ["2+2"],
-                    },
-                ],
-            });
-        });
-    });
-});

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

@@ -1,12 +0,0 @@
-// http://www.datypic.com/sc/ooxml/e-m_r-1.html
-import { XmlComponent } from "@file/xml-components";
-
-import { MathText } from "./math-text";
-
-export class MathRun extends XmlComponent {
-    public constructor(text: string) {
-        super("m:r");
-
-        this.root.push(new MathText(text));
-    }
-}

package/src/file/paragraph/math/math-text.spec.ts

@@ -1,17 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { MathText } from "./math-text";
-
-describe("MathText", () => {
-    describe("#constructor()", () => {
-        it("should create a MathText with correct root key", () => {
-            const mathText = new MathText("2+2");
-            const tree = new Formatter().format(mathText);
-            expect(tree).to.deep.equal({
-                "m:t": ["2+2"],
-            });
-        });
-    });
-});

package/src/file/paragraph/math/math-text.ts

@@ -1,9 +0,0 @@
-import { XmlComponent } from "@file/xml-components";
-
-export class MathText extends XmlComponent {
-    public constructor(text: string) {
-        super("m:t");
-
-        this.root.push(text);
-    }
-}

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

@@ -1,38 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { Math } from "./math";
-import { MathRun } from "./math-run";
-
-describe("Math", () => {
-    describe("#constructor()", () => {
-        it("should create a Math with correct root key", () => {
-            const math = new Math({
-                children: [],
-            });
-            const tree = new Formatter().format(math);
-            expect(tree).to.deep.equal({
-                "m:oMath": {},
-            });
-        });
-
-        it("should be able to add children", () => {
-            const math = new Math({
-                children: [new MathRun("2+2")],
-            });
-            const tree = new Formatter().format(math);
-            expect(tree).to.deep.equal({
-                "m:oMath": [
-                    {
-                        "m:r": [
-                            {
-                                "m:t": ["2+2"],
-                            },
-                        ],
-                    },
-                ],
-            });
-        });
-    });
-});

package/src/file/paragraph/math/math.ts

@@ -1,18 +0,0 @@
-// http://www.datypic.com/sc/ooxml/e-m_oMath-1.html
-import { XmlComponent } from "@file/xml-components";
-
-import { MathComponent } from "./math-component";
-
-export interface IMathOptions {
-    readonly children: readonly MathComponent[];
-}
-
-export class Math extends XmlComponent {
-    public constructor(options: IMathOptions) {
-        super("m:oMath");
-
-        for (const child of options.children) {
-            this.root.push(child);
-        }
-    }
-}

package/src/file/paragraph/math/n-ary/index.ts

@@ -1,8 +0,0 @@
-export * from "./math-accent-character";
-export * from "./math-base";
-export * from "./math-limit-location";
-export * from "./math-n-ary-properties";
-export * from "./math-sub-script";
-export * from "./math-sum";
-export * from "./math-integral";
-export * from "./math-super-script";

package/src/file/paragraph/math/n-ary/math-accent-character.spec.ts

@@ -1,22 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { MathAccentCharacter } from "./math-accent-character";
-
-describe("MathAccentCharacter", () => {
-    describe("#constructor()", () => {
-        it("should create a MathAccentCharacter with correct root key", () => {
-            const mathAccentCharacter = new MathAccentCharacter("∑");
-
-            const tree = new Formatter().format(mathAccentCharacter);
-            expect(tree).to.deep.equal({
-                "m:chr": {
-                    _attr: {
-                        "m:val": "∑",
-                    },
-                },
-            });
-        });
-    });
-});

package/src/file/paragraph/math/n-ary/math-accent-character.ts

@@ -1,14 +0,0 @@
-// http://www.datypic.com/sc/ooxml/e-m_chr-1.html
-import { XmlAttributeComponent, XmlComponent } from "@file/xml-components";
-
-class MathAccentCharacterAttributes extends XmlAttributeComponent<{ readonly accent: string }> {
-    protected readonly xmlKeys = { accent: "m:val" };
-}
-
-export class MathAccentCharacter extends XmlComponent {
-    public constructor(accent: string) {
-        super("m:chr");
-
-        this.root.push(new MathAccentCharacterAttributes({ accent }));
-    }
-}

package/src/file/paragraph/math/n-ary/math-base.spec.ts

@@ -1,27 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { MathRun } from "../math-run";
-import { MathBase } from "./math-base";
-
-describe("MathBase", () => {
-    describe("#constructor()", () => {
-        it("should create a MathBase with correct root key", () => {
-            const mathBase = new MathBase([new MathRun("2+2")]);
-
-            const tree = new Formatter().format(mathBase);
-            expect(tree).to.deep.equal({
-                "m:e": [
-                    {
-                        "m:r": [
-                            {
-                                "m:t": ["2+2"],
-                            },
-                        ],
-                    },
-                ],
-            });
-        });
-    });
-});

package/src/file/paragraph/math/n-ary/math-base.ts

@@ -1,14 +0,0 @@
-// http://www.datypic.com/sc/ooxml/e-m_e-1.html
-import { XmlComponent } from "@file/xml-components";
-
-import { MathComponent } from "../math-component";
-
-export class MathBase extends XmlComponent {
-    public constructor(children: readonly MathComponent[]) {
-        super("m:e");
-
-        for (const child of children) {
-            this.root.push(child);
-        }
-    }
-}

package/src/file/paragraph/math/n-ary/math-integral.spec.ts

@@ -1,116 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { MathRun } from "../math-run";
-import { MathIntegral } from "./math-integral";
-
-describe("MathIntegral", () => {
-    describe("#constructor()", () => {
-        it("should create a MathIntegral with correct root key", () => {
-            const mathIntegral = new MathIntegral({
-                children: [new MathRun("1")],
-                subScript: [new MathRun("2")],
-                superScript: [new MathRun("3")],
-            });
-
-            const tree = new Formatter().format(mathIntegral);
-            expect(tree).to.deep.equal({
-                "m:nary": [
-                    {
-                        "m:naryPr": [
-                            {
-                                "m:limLoc": {
-                                    _attr: {
-                                        "m:val": "undOvr",
-                                    },
-                                },
-                            },
-                        ],
-                    },
-                    {
-                        "m:sub": [
-                            {
-                                "m:r": [
-                                    {
-                                        "m:t": ["2"],
-                                    },
-                                ],
-                            },
-                        ],
-                    },
-                    {
-                        "m:sup": [
-                            {
-                                "m:r": [
-                                    {
-                                        "m:t": ["3"],
-                                    },
-                                ],
-                            },
-                        ],
-                    },
-                    {
-                        "m:e": [
-                            {
-                                "m:r": [
-                                    {
-                                        "m:t": ["1"],
-                                    },
-                                ],
-                            },
-                        ],
-                    },
-                ],
-            });
-        });
-
-        it("should create a MathIntegral with correct root key without sub-script and super-scripts", () => {
-            const mathIntegral = new MathIntegral({
-                children: [new MathRun("1")],
-            });
-
-            const tree = new Formatter().format(mathIntegral);
-            expect(tree).to.deep.equal({
-                "m:nary": [
-                    {
-                        "m:naryPr": [
-                            {
-                                "m:limLoc": {
-                                    _attr: {
-                                        "m:val": "undOvr",
-                                    },
-                                },
-                            },
-                            {
-                                "m:supHide": {
-                                    _attr: {
-                                        "m:val": 1,
-                                    },
-                                },
-                            },
-                            {
-                                "m:subHide": {
-                                    _attr: {
-                                        "m:val": 1,
-                                    },
-                                },
-                            },
-                        ],
-                    },
-                    {
-                        "m:e": [
-                            {
-                                "m:r": [
-                                    {
-                                        "m:t": ["1"],
-                                    },
-                                ],
-                            },
-                        ],
-                    },
-                ],
-            });
-        });
-    });
-});

package/src/file/paragraph/math/n-ary/math-integral.ts

@@ -1,31 +0,0 @@
-import { XmlComponent } from "@file/xml-components";
-
-import { MathComponent } from "../math-component";
-import { MathBase } from "./math-base";
-import { MathNAryProperties } from "./math-n-ary-properties";
-import { MathSubScriptElement } from "./math-sub-script";
-import { MathSuperScriptElement } from "./math-super-script";
-
-export interface IMathIntegralOptions {
-    readonly children: readonly MathComponent[];
-    readonly subScript?: readonly MathComponent[];
-    readonly superScript?: readonly MathComponent[];
-}
-
-export class MathIntegral extends XmlComponent {
-    public constructor(options: IMathIntegralOptions) {
-        super("m:nary");
-
-        this.root.push(new MathNAryProperties("", !!options.superScript, !!options.subScript));
-
-        if (!!options.subScript) {
-            this.root.push(new MathSubScriptElement(options.subScript));
-        }
-
-        if (!!options.superScript) {
-            this.root.push(new MathSuperScriptElement(options.superScript));
-        }
-
-        this.root.push(new MathBase(options.children));
-    }
-}

package/src/file/paragraph/math/n-ary/math-limit-location.spec.ts

@@ -1,22 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { MathLimitLocation } from "./math-limit-location";
-
-describe("MathLimitLocation", () => {
-    describe("#constructor()", () => {
-        it("should create a MathLimitLocation with correct root key", () => {
-            const mathLimitLocation = new MathLimitLocation();
-
-            const tree = new Formatter().format(mathLimitLocation);
-            expect(tree).to.deep.equal({
-                "m:limLoc": {
-                    _attr: {
-                        "m:val": "undOvr",
-                    },
-                },
-            });
-        });
-    });
-});

package/src/file/paragraph/math/n-ary/math-limit-location.ts

@@ -1,14 +0,0 @@
-// http://www.datypic.com/sc/ooxml/e-m_limLoc-1.html
-import { XmlAttributeComponent, XmlComponent } from "@file/xml-components";
-
-class MathLimitLocationAttributes extends XmlAttributeComponent<{ readonly value: string }> {
-    protected readonly xmlKeys = { value: "m:val" };
-}
-
-export class MathLimitLocation extends XmlComponent {
-    public constructor() {
-        super("m:limLoc");
-
-        this.root.push(new MathLimitLocationAttributes({ value: "undOvr" }));
-    }
-}

package/src/file/paragraph/math/n-ary/math-n-ary-properties.spec.ts

@@ -1,133 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { MathNAryProperties } from "./math-n-ary-properties";
-
-describe("MathNAryProperties", () => {
-    describe("#constructor()", () => {
-        it("should create a MathNAryProperties with correct root key", () => {
-            const mathNAryProperties = new MathNAryProperties("∑", true, true);
-
-            const tree = new Formatter().format(mathNAryProperties);
-            expect(tree).to.deep.equal({
-                "m:naryPr": [
-                    {
-                        "m:chr": {
-                            _attr: {
-                                "m:val": "∑",
-                            },
-                        },
-                    },
-                    {
-                        "m:limLoc": {
-                            _attr: {
-                                "m:val": "undOvr",
-                            },
-                        },
-                    },
-                ],
-            });
-        });
-
-        it("should add super-script hide attributes", () => {
-            const mathNAryProperties = new MathNAryProperties("∑", false, true);
-
-            const tree = new Formatter().format(mathNAryProperties);
-            expect(tree).to.deep.equal({
-                "m:naryPr": [
-                    {
-                        "m:chr": {
-                            _attr: {
-                                "m:val": "∑",
-                            },
-                        },
-                    },
-                    {
-                        "m:limLoc": {
-                            _attr: {
-                                "m:val": "undOvr",
-                            },
-                        },
-                    },
-                    {
-                        "m:supHide": {
-                            _attr: {
-                                "m:val": 1,
-                            },
-                        },
-                    },
-                ],
-            });
-        });
-
-        it("should add sub-script hide attributes", () => {
-            const mathNAryProperties = new MathNAryProperties("∑", true, false);
-
-            const tree = new Formatter().format(mathNAryProperties);
-            expect(tree).to.deep.equal({
-                "m:naryPr": [
-                    {
-                        "m:chr": {
-                            _attr: {
-                                "m:val": "∑",
-                            },
-                        },
-                    },
-                    {
-                        "m:limLoc": {
-                            _attr: {
-                                "m:val": "undOvr",
-                            },
-                        },
-                    },
-                    {
-                        "m:subHide": {
-                            _attr: {
-                                "m:val": 1,
-                            },
-                        },
-                    },
-                ],
-            });
-        });
-
-        it("should add both super-script and sub-script hide attributes", () => {
-            const mathNAryProperties = new MathNAryProperties("∑", false, false);
-
-            const tree = new Formatter().format(mathNAryProperties);
-            expect(tree).to.deep.equal({
-                "m:naryPr": [
-                    {
-                        "m:chr": {
-                            _attr: {
-                                "m:val": "∑",
-                            },
-                        },
-                    },
-                    {
-                        "m:limLoc": {
-                            _attr: {
-                                "m:val": "undOvr",
-                            },
-                        },
-                    },
-                    {
-                        "m:supHide": {
-                            _attr: {
-                                "m:val": 1,
-                            },
-                        },
-                    },
-                    {
-                        "m:subHide": {
-                            _attr: {
-                                "m:val": 1,
-                            },
-                        },
-                    },
-                ],
-            });
-        });
-    });
-});

package/src/file/paragraph/math/n-ary/math-n-ary-properties.ts

@@ -1,26 +0,0 @@
-// http://www.datypic.com/sc/ooxml/e-m_naryPr-1.html
-import { XmlComponent } from "@file/xml-components";
-
-import { MathAccentCharacter } from "./math-accent-character";
-import { MathLimitLocation } from "./math-limit-location";
-import { MathSubScriptHide } from "./math-sub-script-hide";
-import { MathSuperScriptHide } from "./math-super-script-hide";
-
-export class MathNAryProperties extends XmlComponent {
-    public constructor(accent: string, hasSuperScript: boolean, hasSubScript: boolean) {
-        super("m:naryPr");
-
-        if (!!accent) {
-            this.root.push(new MathAccentCharacter(accent));
-        }
-        this.root.push(new MathLimitLocation());
-
-        if (!hasSuperScript) {
-            this.root.push(new MathSuperScriptHide());
-        }
-
-        if (!hasSubScript) {
-            this.root.push(new MathSubScriptHide());
-        }
-    }
-}