docx 8.0.0 → 8.0.1

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",
-    };
-}

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

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

package/src/file/core-properties/index.ts

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

package/src/file/core-properties/properties.spec.ts

@@ -1,71 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { CoreProperties } from "./properties";
-
-describe("Properties", () => {
-    describe("#constructor()", () => {
-        it("sets the appropriate attributes on the top-level", () => {
-            const properties = new CoreProperties({});
-            const tree = new Formatter().format(properties);
-            expect(Object.keys(tree)).to.deep.equal(["cp:coreProperties"]);
-            expect(tree["cp:coreProperties"]).to.be.an.instanceof(Array);
-            expect(tree["cp:coreProperties"][0]).to.deep.equal({
-                _attr: {
-                    "xmlns:cp": "http://schemas.openxmlformats.org/package/2006/metadata/core-properties",
-                    "xmlns:dc": "http://purl.org/dc/elements/1.1/",
-                    "xmlns:dcmitype": "http://purl.org/dc/dcmitype/",
-                    "xmlns:dcterms": "http://purl.org/dc/terms/",
-                    "xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance",
-                },
-            });
-        });
-
-        it("should create properties with a title", () => {
-            const properties = new CoreProperties({ title: "test document" });
-            const tree = new Formatter().format(properties);
-            expect(Object.keys(tree)).to.deep.equal(["cp:coreProperties"]);
-            expect(tree["cp:coreProperties"]).to.be.an.instanceof(Array);
-            expect(tree["cp:coreProperties"]).to.deep.include({ "dc:title": ["test document"] });
-        });
-
-        it("should create properties with all the attributes given", () => {
-            const properties = new CoreProperties({
-                title: "test document",
-                subject: "test subject",
-                creator: "me",
-                keywords: "test docx",
-                description: "testing document",
-                lastModifiedBy: "the author",
-                revision: 123,
-            });
-            const tree = new Formatter().format(properties);
-            expect(Object.keys(tree)).to.deep.equal(["cp:coreProperties"]);
-            expect(tree["cp:coreProperties"]).to.be.an.instanceof(Array);
-
-            const key = (obj) => Object.keys(obj)[0];
-            expect(tree["cp:coreProperties"].map(key)).to.include.members([
-                "_attr",
-                "cp:keywords",
-                "cp:lastModifiedBy",
-                "cp:revision",
-                "dc:creator",
-                "dc:description",
-                "dc:subject",
-                "dc:title",
-                "dcterms:created",
-                "dcterms:modified",
-            ]);
-            expect(tree["cp:coreProperties"]).to.deep.include.members([
-                { "cp:keywords": ["test docx"] },
-                { "cp:lastModifiedBy": ["the author"] },
-                { "cp:revision": ["123"] },
-                { "dc:creator": ["me"] },
-                { "dc:description": ["testing document"] },
-                { "dc:subject": ["test subject"] },
-                { "dc:title": ["test document"] },
-            ]);
-        });
-    });
-});