docx 7.8.2 → 8.0.1

package/src/export/packer/packer.spec.ts

@@ -1,175 +0,0 @@
-/* tslint:disable:typedef space-before-function-paren */
-import { assert } from "chai";
-import { mock, stub } from "sinon";
-
-import { File } from "@file/file";
-import { HeadingLevel, Paragraph } from "@file/paragraph";
-
-import { Packer } from "./packer";
-
-describe("Packer", () => {
-    let file: File;
-
-    beforeEach(() => {
-        file = new File({
-            creator: "Dolan Miu",
-            revision: 1,
-            lastModifiedBy: "Dolan Miu",
-            sections: [
-                {
-                    children: [
-                        new Paragraph({
-                            text: "title",
-                            heading: HeadingLevel.TITLE,
-                        }),
-                        new Paragraph({
-                            text: "Hello world",
-                            heading: HeadingLevel.HEADING_1,
-                        }),
-                        new Paragraph({
-                            text: "heading 2",
-                            heading: HeadingLevel.HEADING_2,
-                        }),
-                        new Paragraph("test text"),
-                    ],
-                },
-            ],
-        });
-    });
-
-    describe("#toString()", () => {
-        it("should return a non-empty string", async () => {
-            const result = await Packer.toString(file);
-
-            assert.isAbove(result.length, 0);
-        });
-    });
-
-    describe("#toBuffer()", () => {
-        it("should create a standard docx file", async function () {
-            this.timeout(99999999);
-            const buffer = await Packer.toBuffer(file);
-
-            assert.isDefined(buffer);
-            assert.isTrue(buffer.byteLength > 0);
-        });
-
-        it("should handle exception if it throws any", () => {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const compiler = stub((Packer as any).compiler, "compile");
-
-            compiler.throwsException();
-            return Packer.toBuffer(file).catch((error) => {
-                assert.isDefined(error);
-            });
-        });
-
-        after(() => {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            (Packer as any).compiler.compile.restore();
-        });
-    });
-
-    describe("#toBase64String()", () => {
-        it("should create a standard docx file", async function () {
-            this.timeout(99999999);
-            const str = await Packer.toBase64String(file);
-
-            assert.isDefined(str);
-            assert.isTrue(str.length > 0);
-        });
-
-        it("should handle exception if it throws any", () => {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const compiler = stub((Packer as any).compiler, "compile");
-
-            compiler.throwsException();
-            return Packer.toBase64String(file).catch((error) => {
-                assert.isDefined(error);
-            });
-        });
-
-        after(() => {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            (Packer as any).compiler.compile.restore();
-        });
-    });
-
-    describe("#toBlob()", () => {
-        it("should create a standard docx file", async () => {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            stub((Packer as any).compiler, "compile").callsFake(() => ({
-                // tslint:disable-next-line: no-empty
-                generateAsync: () => mock({}),
-            }));
-            const str = await Packer.toBlob(file);
-
-            assert.isDefined(str);
-        });
-
-        it("should handle exception if it throws any", () => {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const compiler = stub((Packer as any).compiler, "compile");
-
-            compiler.throwsException();
-            return Packer.toBlob(file).catch((error) => {
-                assert.isDefined(error);
-            });
-        });
-
-        afterEach(() => {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            (Packer as any).compiler.compile.restore();
-        });
-    });
-
-    describe("#toStream()", () => {
-        it("should create a standard docx file", async () => {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            stub((Packer as any).compiler, "compile").callsFake(() => ({
-                // tslint:disable-next-line: no-empty
-                generateNodeStream: () => ({
-                    on: (event: string, cb: () => void) => {
-                        if (event === "end") {
-                            cb();
-                        }
-                    },
-                }),
-            }));
-            const stream = await Packer.toStream(file);
-            return new Promise((resolve, reject) => {
-                stream.on("error", () => {
-                    reject(new Error());
-                });
-
-                stream.on("end", () => {
-                    resolve();
-                });
-            });
-        });
-
-        it("should handle exception if it throws any", () => {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const compiler = stub((Packer as any).compiler, "compile").callsFake(() => ({
-                // tslint:disable-next-line: no-empty
-                on: (event: string, cb: () => void) => {
-                    if (event === "error") {
-                        cb();
-                    }
-                },
-            }));
-
-            compiler.throwsException();
-            try {
-                Packer.toStream(file);
-            } catch (error) {
-                assert.isDefined(error);
-            }
-        });
-
-        afterEach(() => {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            (Packer as any).compiler.compile.restore();
-        });
-    });
-});

package/src/export/packer/packer.ts

@@ -1,74 +0,0 @@
-import { Stream } from "stream";
-import { File } from "@file/file";
-
-import { Compiler } from "./next-compiler";
-
-/**
- * Use blanks to prettify
- */
-export enum PrettifyType {
-    NONE = "",
-    WITH_2_BLANKS = "  ",
-    WITH_4_BLANKS = "    ",
-    WITH_TAB = "\t",
-}
-
-export class Packer {
-    public static async toString(file: File, prettify?: boolean | PrettifyType): Promise<string> {
-        const zip = this.compiler.compile(file, prettify);
-        const zipData = await zip.generateAsync({
-            type: "string",
-            mimeType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-            compression: "DEFLATE",
-        });
-
-        return zipData;
-    }
-
-    public static async toBuffer(file: File, prettify?: boolean | PrettifyType): Promise<Buffer> {
-        const zip = this.compiler.compile(file, prettify);
-        const zipData = await zip.generateAsync({
-            type: "nodebuffer",
-            mimeType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-            compression: "DEFLATE",
-        });
-
-        return zipData;
-    }
-
-    public static async toBase64String(file: File, prettify?: boolean | PrettifyType): Promise<string> {
-        const zip = this.compiler.compile(file, prettify);
-        const zipData = await zip.generateAsync({
-            type: "base64",
-            mimeType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-            compression: "DEFLATE",
-        });
-
-        return zipData;
-    }
-
-    public static async toBlob(file: File, prettify?: boolean | PrettifyType): Promise<Blob> {
-        const zip = this.compiler.compile(file, prettify);
-        const zipData = await zip.generateAsync({
-            type: "blob",
-            mimeType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-            compression: "DEFLATE",
-        });
-
-        return zipData;
-    }
-
-    public static toStream(file: File, prettify?: boolean | PrettifyType): Stream {
-        const zip = this.compiler.compile(file, prettify);
-        const zipData = zip.generateNodeStream({
-            type: "nodebuffer",
-            streamFiles: true,
-            mimeType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-            compression: "DEFLATE",
-        });
-
-        return zipData;
-    }
-
-    private static readonly compiler = new Compiler();
-}

package/src/file/app-properties/app-properties-attributes.ts

@@ -1,11 +0,0 @@
-import { XmlAttributeComponent } from "@file/xml-components";
-
-export class AppPropertiesAttributes extends XmlAttributeComponent<{
-    readonly xmlns: string;
-    readonly vt: string;
-}> {
-    protected readonly xmlKeys = {
-        xmlns: "xmlns",
-        vt: "xmlns:vt",
-    };
-}

package/src/file/app-properties/app-properties.ts

@@ -1,15 +0,0 @@
-import { XmlComponent } from "@file/xml-components";
-import { AppPropertiesAttributes } from "./app-properties-attributes";
-
-export class AppProperties extends XmlComponent {
-    public constructor() {
-        super("Properties");
-
-        this.root.push(
-            new AppPropertiesAttributes({
-                xmlns: "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties",
-                vt: "http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes",
-            }),
-        );
-    }
-}

package/src/file/border/border.spec.ts

@@ -1,54 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-import { BorderStyle } from "@file/border";
-
-import { BorderElement } from "./border";
-
-describe("BorderElement", () => {
-    describe("#constructor", () => {
-        it("should create a simple border element", () => {
-            const border = new BorderElement("w:top", {
-                style: BorderStyle.SINGLE,
-            });
-            const tree = new Formatter().format(border);
-            expect(tree).to.deep.equal({
-                "w:top": {
-                    _attr: {
-                        "w:val": "single",
-                    },
-                },
-            });
-        });
-        it("should create a simple border element with a size", () => {
-            const border = new BorderElement("w:top", {
-                style: BorderStyle.SINGLE,
-                size: 22,
-            });
-            const tree = new Formatter().format(border);
-            expect(tree).to.deep.equal({
-                "w:top": {
-                    _attr: {
-                        "w:val": "single",
-                        "w:sz": 22,
-                    },
-                },
-            });
-        });
-        it("should create a simple border element with space", () => {
-            const border = new BorderElement("w:top", {
-                style: BorderStyle.SINGLE,
-                space: 22,
-            });
-            const tree = new Formatter().format(border);
-            expect(tree).to.deep.equal({
-                "w:top": {
-                    _attr: {
-                        "w:val": "single",
-                        "w:space": 22,
-                    },
-                },
-            });
-        });
-    });
-});

package/src/file/border/border.ts

@@ -1,86 +0,0 @@
-// Note that the border type is identical in all places,
-// regardless of where it's used like paragraph/table/etc.
-// PageBorders are a superset, but we're not using any of those extras.
-//
-// http://officeopenxml.com/WPborders.php
-// http://officeopenxml.com/WPtableBorders.php
-// http://officeopenxml.com/WPtableCellProperties-Borders.php
-// http://officeopenxml.com/WPsectionBorders.php
-//
-// This describes the CT_Border type.
-// <xsd:complexType name="CT_Border">
-//     <xsd:attribute name="val" type="ST_Border" use="required"/>
-//     <xsd:attribute name="color" type="ST_HexColor" use="optional" default="auto"/>
-//     <xsd:attribute name="themeColor" type="ST_ThemeColor" use="optional"/>
-//     <xsd:attribute name="themeTint" type="ST_UcharHexNumber" use="optional"/>
-//     <xsd:attribute name="themeShade" type="ST_UcharHexNumber" use="optional"/>
-//     <xsd:attribute name="sz" type="ST_EighthPointMeasure" use="optional"/>
-//     <xsd:attribute name="space" type="ST_PointMeasure" use="optional" default="0"/>
-//     <xsd:attribute name="shadow" type="s:ST_OnOff" use="optional"/>
-//     <xsd:attribute name="frame" type="s:ST_OnOff" use="optional"/>
-// </xsd:complexType>
-import { XmlAttributeComponent, XmlComponent } from "@file/xml-components";
-import { eighthPointMeasureValue, hexColorValue, pointMeasureValue } from "@util/values";
-
-export interface IBorderOptions {
-    readonly style: BorderStyle;
-    /** Border color, in hex (eg 'FF00AA') */
-    readonly color?: string;
-    /** Size of the border in 1/8 pt */
-    readonly size?: number;
-    /** Spacing offset. Values are specified in pt */
-    readonly space?: number;
-}
-
-export class BorderElement extends XmlComponent {
-    public constructor(elementName: string, { color, size, space, style }: IBorderOptions) {
-        super(elementName);
-        this.root.push(
-            new BordersAttributes({
-                style,
-                color: color === undefined ? undefined : hexColorValue(color),
-                size: size === undefined ? undefined : eighthPointMeasureValue(size),
-                space: space === undefined ? undefined : pointMeasureValue(space),
-            }),
-        );
-    }
-}
-
-class BordersAttributes extends XmlAttributeComponent<IBorderOptions> {
-    protected readonly xmlKeys = {
-        style: "w:val",
-        color: "w:color",
-        size: "w:sz",
-        space: "w:space",
-    };
-}
-
-export enum BorderStyle {
-    SINGLE = "single",
-    DASH_DOT_STROKED = "dashDotStroked",
-    DASHED = "dashed",
-    DASH_SMALL_GAP = "dashSmallGap",
-    DOT_DASH = "dotDash",
-    DOT_DOT_DASH = "dotDotDash",
-    DOTTED = "dotted",
-    DOUBLE = "double",
-    DOUBLE_WAVE = "doubleWave",
-    INSET = "inset",
-    NIL = "nil",
-    NONE = "none",
-    OUTSET = "outset",
-    THICK = "thick",
-    THICK_THIN_LARGE_GAP = "thickThinLargeGap",
-    THICK_THIN_MEDIUM_GAP = "thickThinMediumGap",
-    THICK_THIN_SMALL_GAP = "thickThinSmallGap",
-    THIN_THICK_LARGE_GAP = "thinThickLargeGap",
-    THIN_THICK_MEDIUM_GAP = "thinThickMediumGap",
-    THIN_THICK_SMALL_GAP = "thinThickSmallGap",
-    THIN_THICK_THIN_LARGE_GAP = "thinThickThinLargeGap",
-    THIN_THICK_THIN_MEDIUM_GAP = "thinThickThinMediumGap",
-    THIN_THICK_THIN_SMALL_GAP = "thinThickThinSmallGap",
-    THREE_D_EMBOSS = "threeDEmboss",
-    THREE_D_ENGRAVE = "threeDEngrave",
-    TRIPLE = "triple",
-    WAVE = "wave",
-}

package/src/file/border/index.ts

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

package/src/file/content-types/content-types-attributes.ts

@@ -1,9 +0,0 @@
-import { XmlAttributeComponent } from "@file/xml-components";
-
-export class ContentTypeAttributes extends XmlAttributeComponent<{
-    readonly xmlns?: string;
-}> {
-    protected readonly xmlKeys = {
-        xmlns: "xmlns",
-    };
-}

package/src/file/content-types/content-types.spec.ts

@@ -1,150 +0,0 @@
-// tslint:disable:no-string-literal
-
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { ContentTypes } from "./content-types";
-
-describe("ContentTypes", () => {
-    let contentTypes: ContentTypes;
-
-    beforeEach(() => {
-        contentTypes = new ContentTypes();
-    });
-
-    describe("#constructor()", () => {
-        it("should create default content types", () => {
-            const tree = new Formatter().format(contentTypes);
-
-            expect(tree["Types"]).to.be.an.instanceof(Array);
-
-            expect(tree["Types"][0]).to.deep.equal({ _attr: { xmlns: "http://schemas.openxmlformats.org/package/2006/content-types" } });
-            expect(tree["Types"][1]).to.deep.equal({ Default: { _attr: { ContentType: "image/png", Extension: "png" } } });
-            expect(tree["Types"][2]).to.deep.equal({ Default: { _attr: { ContentType: "image/jpeg", Extension: "jpeg" } } });
-            expect(tree["Types"][3]).to.deep.equal({ Default: { _attr: { ContentType: "image/jpeg", Extension: "jpg" } } });
-            expect(tree["Types"][4]).to.deep.equal({ Default: { _attr: { ContentType: "image/bmp", Extension: "bmp" } } });
-            expect(tree["Types"][5]).to.deep.equal({ Default: { _attr: { ContentType: "image/gif", Extension: "gif" } } });
-            expect(tree["Types"][6]).to.deep.equal({
-                Default: { _attr: { ContentType: "application/vnd.openxmlformats-package.relationships+xml", Extension: "rels" } },
-            });
-            expect(tree["Types"][7]).to.deep.equal({ Default: { _attr: { ContentType: "application/xml", Extension: "xml" } } });
-            expect(tree["Types"][8]).to.deep.equal({
-                Override: {
-                    _attr: {
-                        ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml",
-                        PartName: "/word/document.xml",
-                    },
-                },
-            });
-            expect(tree["Types"][9]).to.deep.equal({
-                Override: {
-                    _attr: {
-                        ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml",
-                        PartName: "/word/styles.xml",
-                    },
-                },
-            });
-            expect(tree["Types"][10]).to.deep.equal({
-                Override: {
-                    _attr: {
-                        ContentType: "application/vnd.openxmlformats-package.core-properties+xml",
-                        PartName: "/docProps/core.xml",
-                    },
-                },
-            });
-            expect(tree["Types"][11]).to.deep.equal({
-                Override: {
-                    _attr: {
-                        ContentType: "application/vnd.openxmlformats-officedocument.custom-properties+xml",
-                        PartName: "/docProps/custom.xml",
-                    },
-                },
-            });
-            expect(tree["Types"][12]).to.deep.equal({
-                Override: {
-                    _attr: {
-                        ContentType: "application/vnd.openxmlformats-officedocument.extended-properties+xml",
-                        PartName: "/docProps/app.xml",
-                    },
-                },
-            });
-            expect(tree["Types"][13]).to.deep.equal({
-                Override: {
-                    _attr: {
-                        ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml",
-                        PartName: "/word/numbering.xml",
-                    },
-                },
-            });
-            expect(tree["Types"][14]).to.deep.equal({
-                Override: {
-                    _attr: {
-                        ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml",
-                        PartName: "/word/footnotes.xml",
-                    },
-                },
-            });
-            expect(tree["Types"][15]).to.deep.equal({
-                Override: {
-                    _attr: {
-                        ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml",
-                        PartName: "/word/settings.xml",
-                    },
-                },
-            });
-        });
-    });
-
-    describe("#addFooter()", () => {
-        it("should add footer", () => {
-            contentTypes.addFooter(101);
-            contentTypes.addFooter(102);
-            const tree = new Formatter().format(contentTypes);
-
-            expect(tree["Types"][17]).to.deep.equal({
-                Override: {
-                    _attr: {
-                        ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml",
-                        PartName: "/word/footer101.xml",
-                    },
-                },
-            });
-
-            expect(tree["Types"][18]).to.deep.equal({
-                Override: {
-                    _attr: {
-                        ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml",
-                        PartName: "/word/footer102.xml",
-                    },
-                },
-            });
-        });
-    });
-
-    describe("#addHeader()", () => {
-        it("should add header", () => {
-            contentTypes.addHeader(201);
-            contentTypes.addHeader(202);
-            const tree = new Formatter().format(contentTypes);
-
-            expect(tree["Types"][17]).to.deep.equal({
-                Override: {
-                    _attr: {
-                        ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml",
-                        PartName: "/word/header201.xml",
-                    },
-                },
-            });
-
-            expect(tree["Types"][18]).to.deep.equal({
-                Override: {
-                    _attr: {
-                        ContentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml",
-                        PartName: "/word/header202.xml",
-                    },
-                },
-            });
-        });
-    });
-});

package/src/file/content-types/content-types.ts

@@ -1,49 +0,0 @@
-import { XmlComponent } from "@file/xml-components";
-import { ContentTypeAttributes } from "./content-types-attributes";
-import { Default } from "./default/default";
-import { Override } from "./override/override";
-
-export class ContentTypes extends XmlComponent {
-    public constructor() {
-        super("Types");
-
-        this.root.push(
-            new ContentTypeAttributes({
-                xmlns: "http://schemas.openxmlformats.org/package/2006/content-types",
-            }),
-        );
-
-        this.root.push(new Default("image/png", "png"));
-        this.root.push(new Default("image/jpeg", "jpeg"));
-        this.root.push(new Default("image/jpeg", "jpg"));
-        this.root.push(new Default("image/bmp", "bmp"));
-        this.root.push(new Default("image/gif", "gif"));
-        this.root.push(new Default("application/vnd.openxmlformats-package.relationships+xml", "rels"));
-        this.root.push(new Default("application/xml", "xml"));
-
-        this.root.push(
-            new Override("application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml", "/word/document.xml"),
-        );
-
-        this.root.push(new Override("application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml", "/word/styles.xml"));
-        this.root.push(new Override("application/vnd.openxmlformats-package.core-properties+xml", "/docProps/core.xml"));
-        this.root.push(new Override("application/vnd.openxmlformats-officedocument.custom-properties+xml", "/docProps/custom.xml"));
-        this.root.push(new Override("application/vnd.openxmlformats-officedocument.extended-properties+xml", "/docProps/app.xml"));
-        this.root.push(new Override("application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml", "/word/numbering.xml"));
-        this.root.push(new Override("application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml", "/word/footnotes.xml"));
-        this.root.push(new Override("application/vnd.openxmlformats-officedocument.wordprocessingml.settings+xml", "/word/settings.xml"));
-        this.root.push(new Override("application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml", "/word/comments.xml"));
-    }
-
-    public addFooter(index: number): void {
-        this.root.push(
-            new Override("application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml", `/word/footer${index}.xml`),
-        );
-    }
-
-    public addHeader(index: number): void {
-        this.root.push(
-            new Override("application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml", `/word/header${index}.xml`),
-        );
-    }
-}

package/src/file/content-types/default/default-attributes.ts

@@ -1,11 +0,0 @@
-import { XmlAttributeComponent } from "@file/xml-components";
-
-export class DefaultAttributes extends XmlAttributeComponent<{
-    readonly contentType: string;
-    readonly extension?: string;
-}> {
-    protected readonly xmlKeys = {
-        contentType: "ContentType",
-        extension: "Extension",
-    };
-}

package/src/file/content-types/default/default.ts

@@ -1,15 +0,0 @@
-import { XmlComponent } from "@file/xml-components";
-import { DefaultAttributes } from "./default-attributes";
-
-export class Default extends XmlComponent {
-    public constructor(contentType: string, extension?: string) {
-        super("Default");
-
-        this.root.push(
-            new DefaultAttributes({
-                contentType: contentType,
-                extension: extension,
-            }),
-        );
-    }
-}

package/src/file/content-types/override/override-attributes.ts

@@ -1,11 +0,0 @@
-import { XmlAttributeComponent } from "@file/xml-components";
-
-export class OverrideAttributes extends XmlAttributeComponent<{
-    readonly contentType: string;
-    readonly partName?: string;
-}> {
-    protected readonly xmlKeys = {
-        contentType: "ContentType",
-        partName: "PartName",
-    };
-}