docx 8.0.0 → 8.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "docx",
-  "version": "8.0.0",
+  "version": "8.0.2",
   "description": "Easily generate .docx files with JS/TS with a nice declarative API. Works for Node and on the Browser.",
   "main": "build/index.js",
   "scripts": {
@@ -28,9 +28,7 @@
     "lint"
   ],
   "files": [
-    "src",
-    "build",
-    "template"
+    "build"
   ],
   "repository": {
     "type": "git",
@@ -61,15 +59,14 @@
   "bugs": {
     "url": "https://github.com/dolanmiu/docx/issues"
   },
-  "homepage": "https://github.com/dolanmiu/docx#readme",
+  "homepage": "https://docx.js.org",
   "devDependencies": {
     "@types/chai": "^4.2.15",
     "@types/chai-as-promised": "^7.1.5",
-    "@types/glob": "^8.0.0",
     "@types/mocha": "^10.0.0",
     "@types/prompt": "^1.1.1",
     "@types/request-promise": "^4.1.42",
-    "@types/shelljs": "^0.8.9",
+    "@types/shelljs": "^0.8.11",
     "@types/sinon": "^10.0.0",
     "@types/unzipper": "^0.10.4",
     "@types/webpack": "^5.0.0",
@@ -107,7 +104,7 @@
     "tsconfig-paths": "^4.0.0",
     "tsconfig-paths-webpack-plugin": "^4.0.0",
     "typedoc": "^0.23.2",
-    "typescript": "5.0.2",
+    "typescript": "5.0.3",
     "unzipper": "^0.10.11",
     "webpack": "^5.28.0",
     "webpack-cli": "^5.0.0"

package/src/export/formatter.spec.ts

@@ -1,118 +0,0 @@
-import { assert, expect } from "chai";
-import * as sinon from "sinon";
-
-import { Formatter } from "@export/formatter";
-import { CoreProperties } from "@file/core-properties";
-import { Paragraph, TextRun } from "@file/paragraph";
-import { Attributes } from "@file/xml-components";
-
-describe("Formatter", () => {
-    let formatter: Formatter;
-
-    beforeEach(() => {
-        formatter = new Formatter();
-    });
-
-    describe("#format()", () => {
-        it("should format simple paragraph", () => {
-            const paragraph = new Paragraph("");
-            const newJson = formatter.format(paragraph);
-            assert.isDefined(newJson["w:p"]);
-        });
-
-        it("should remove xmlKeys", () => {
-            const paragraph = new Paragraph("");
-            const newJson = formatter.format(paragraph);
-            const stringifiedJson = JSON.stringify(newJson);
-            assert(stringifiedJson.indexOf("xmlKeys") < 0);
-        });
-
-        it("should format simple paragraph with bold text", () => {
-            const paragraph = new Paragraph({
-                children: [
-                    new TextRun({
-                        text: "test",
-                        bold: true,
-                    }),
-                ],
-            });
-
-            const tree = formatter.format(paragraph);
-            expect(tree).to.deep.equal({
-                "w:p": [
-                    {
-                        "w:r": [
-                            {
-                                "w:rPr": [
-                                    {
-                                        "w:b": {},
-                                    },
-                                    {
-                                        "w:bCs": {},
-                                    },
-                                ],
-                            },
-                            {
-                                "w:t": [
-                                    {
-                                        _attr: {
-                                            "xml:space": "preserve",
-                                        },
-                                    },
-                                    "test",
-                                ],
-                            },
-                        ],
-                    },
-                ],
-            });
-        });
-
-        it("should format attributes (rsidSect)", () => {
-            const attributes = new Attributes({
-                rsidSect: "test2",
-            });
-            const tree = formatter.format(attributes);
-            expect(tree).to.deep.equal({
-                _attr: {
-                    "w:rsidSect": "test2",
-                },
-            });
-        });
-
-        it("should format attributes (val)", () => {
-            const attributes = new Attributes({
-                val: "test",
-            });
-            const tree = formatter.format(attributes);
-            expect(tree).to.deep.equal({
-                _attr: {
-                    "w:val": "test",
-                },
-            });
-        });
-
-        it("should should change 'p' tag into 'w:p' tag", () => {
-            const paragraph = new Paragraph("");
-            const newJson = formatter.format(paragraph);
-            assert.isDefined(newJson["w:p"]);
-        });
-
-        it("should format Properties object correctly", () => {
-            const properties = new CoreProperties({
-                title: "test document",
-                creator: "Dolan",
-            });
-            const newJson = formatter.format(properties);
-            assert.isDefined(newJson["cp:coreProperties"]);
-        });
-
-        it("should call the prep method only once", () => {
-            const paragraph = new Paragraph("");
-            const spy = sinon.spy(paragraph, "prepForXml");
-
-            formatter.format(paragraph);
-            expect(spy.calledOnce).to.equal(true);
-        });
-    });
-});

package/src/export/formatter.ts

@@ -1,14 +0,0 @@
-import { BaseXmlComponent, IContext, IXmlableObject } from "@file/xml-components";
-
-export class Formatter {
-    // tslint:disable-next-line: no-object-literal-type-assertion
-    public format(input: BaseXmlComponent, context: IContext = { stack: [] } as unknown as IContext): IXmlableObject {
-        const output = input.prepForXml(context);
-
-        if (output) {
-            return output;
-        } else {
-            throw Error("XMLComponent did not format correctly");
-        }
-    }
-}

package/src/export/index.ts

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

package/src/export/packer/image-replacer.spec.ts

@@ -1,61 +0,0 @@
-import { expect } from "chai";
-
-import { Media } from "@file/media";
-
-import { ImageReplacer } from "./image-replacer";
-
-describe("ImageReplacer", () => {
-    describe("#replace()", () => {
-        it("should replace properly", () => {
-            const imageReplacer = new ImageReplacer();
-            const result = imageReplacer.replace(
-                "test {test-image.png} test",
-                [
-                    {
-                        stream: Buffer.from(""),
-                        fileName: "test-image.png",
-                        transformation: {
-                            pixels: {
-                                x: 100,
-                                y: 100,
-                            },
-                            emus: {
-                                x: 100,
-                                y: 100,
-                            },
-                        },
-                    },
-                ],
-                0,
-            );
-
-            expect(result).to.equal("test 0 test");
-        });
-    });
-
-    describe("#getMediaData()", () => {
-        it("should get media data", () => {
-            const imageReplacer = new ImageReplacer();
-            const result = imageReplacer.getMediaData("test {test-image} test", {
-                Array: [
-                    {
-                        stream: Buffer.from(""),
-                        fileName: "test-image",
-                        dimensions: {
-                            pixels: {
-                                x: 100,
-                                y: 100,
-                            },
-                            emus: {
-                                x: 100,
-                                y: 100,
-                            },
-                        },
-                    },
-                ],
-            } as unknown as Media);
-
-            expect(result).to.have.length(1);
-        });
-    });
-});

package/src/export/packer/image-replacer.ts

@@ -1,17 +0,0 @@
-import { IMediaData, Media } from "@file/media";
-
-export class ImageReplacer {
-    public replace(xmlData: string, mediaData: readonly IMediaData[], offset: number): string {
-        let currentXmlData = xmlData;
-
-        mediaData.forEach((image, i) => {
-            currentXmlData = currentXmlData.replace(new RegExp(`{${image.fileName}}`, "g"), (offset + i).toString());
-        });
-
-        return currentXmlData;
-    }
-
-    public getMediaData(xmlData: string, media: Media): readonly IMediaData[] {
-        return media.Array.filter((image) => xmlData.search(`{${image.fileName}}`) > 0);
-    }
-}

package/src/export/packer/next-compiler.spec.ts

@@ -1,180 +0,0 @@
-/* tslint:disable:typedef space-before-function-paren */
-import { expect } from "chai";
-import * as sinon from "sinon";
-
-import { File } from "@file/file";
-import { Footer, Header } from "@file/header";
-import { ImageRun, Paragraph } from "@file/paragraph";
-import * as convenienceFunctions from "@util/convenience-functions";
-
-import { Compiler } from "./next-compiler";
-
-describe("Compiler", () => {
-    let compiler: Compiler;
-
-    beforeEach(() => {
-        compiler = new Compiler();
-    });
-
-    before(() => {
-        sinon.stub(convenienceFunctions, "uniqueId").callsFake(() => "test");
-    });
-
-    after(() => {
-        (convenienceFunctions.uniqueId as sinon.SinonStub).restore();
-    });
-
-    describe("#compile()", () => {
-        it("should pack all the content", function () {
-            this.timeout(99999999);
-            const file = new File({
-                sections: [],
-                comments: {
-                    children: [],
-                },
-            });
-            const zipFile = compiler.compile(file);
-            const fileNames = Object.keys(zipFile.files).map((f) => zipFile.files[f].name);
-
-            expect(fileNames).is.an.instanceof(Array);
-            expect(fileNames).has.length(17);
-            expect(fileNames).to.include("word/document.xml");
-            expect(fileNames).to.include("word/styles.xml");
-            expect(fileNames).to.include("docProps/core.xml");
-            expect(fileNames).to.include("docProps/custom.xml");
-            expect(fileNames).to.include("docProps/app.xml");
-            expect(fileNames).to.include("word/numbering.xml");
-            expect(fileNames).to.include("word/footnotes.xml");
-            expect(fileNames).to.include("word/_rels/footnotes.xml.rels");
-            expect(fileNames).to.include("word/settings.xml");
-            expect(fileNames).to.include("word/comments.xml");
-            expect(fileNames).to.include("word/_rels/document.xml.rels");
-            expect(fileNames).to.include("[Content_Types].xml");
-            expect(fileNames).to.include("_rels/.rels");
-        });
-
-        it("should pack all additional headers and footers", function () {
-            const file = new File({
-                sections: [
-                    {
-                        headers: {
-                            default: new Header({
-                                children: [new Paragraph("test")],
-                            }),
-                        },
-                        footers: {
-                            default: new Footer({
-                                children: [new Paragraph("test")],
-                            }),
-                        },
-                        children: [],
-                    },
-                    {
-                        headers: {
-                            default: new Header({
-                                children: [new Paragraph("test")],
-                            }),
-                        },
-                        footers: {
-                            default: new Footer({
-                                children: [new Paragraph("test")],
-                            }),
-                        },
-                        children: [],
-                    },
-                ],
-            });
-
-            this.timeout(99999999);
-
-            const zipFile = compiler.compile(file);
-            const fileNames = Object.keys(zipFile.files).map((f) => zipFile.files[f].name);
-
-            expect(fileNames).is.an.instanceof(Array);
-            expect(fileNames).has.length(25);
-
-            expect(fileNames).to.include("word/header1.xml");
-            expect(fileNames).to.include("word/_rels/header1.xml.rels");
-            expect(fileNames).to.include("word/header2.xml");
-            expect(fileNames).to.include("word/_rels/header2.xml.rels");
-            expect(fileNames).to.include("word/footer1.xml");
-            expect(fileNames).to.include("word/_rels/footer1.xml.rels");
-            expect(fileNames).to.include("word/footer2.xml");
-            expect(fileNames).to.include("word/_rels/footer2.xml.rels");
-        });
-
-        it("should call the format method X times equalling X files to be formatted", () => {
-            // This test is required because before, there was a case where Document was formatted twice, which was inefficient
-            // This also caused issues such as running prepForXml multiple times as format() was ran multiple times.
-            const paragraph = new Paragraph("");
-            const file = new File({
-                sections: [
-                    {
-                        properties: {},
-                        children: [paragraph],
-                    },
-                ],
-            });
-
-            // tslint:disable-next-line: no-string-literal
-            const spy = sinon.spy(compiler["formatter"], "format");
-
-            compiler.compile(file);
-            expect(spy.callCount).to.equal(13);
-        });
-
-        it("should work with media datas", () => {
-            // This test is required because before, there was a case where Document was formatted twice, which was inefficient
-            // This also caused issues such as running prepForXml multiple times as format() was ran multiple times.
-            const file = new File({
-                sections: [
-                    {
-                        headers: {
-                            default: new Header({
-                                children: [new Paragraph("test")],
-                            }),
-                        },
-                        footers: {
-                            default: new Footer({
-                                children: [new Paragraph("test")],
-                            }),
-                        },
-                        children: [
-                            new Paragraph({
-                                children: [
-                                    new ImageRun({
-                                        data: Buffer.from("", "base64"),
-                                        transformation: {
-                                            width: 100,
-                                            height: 100,
-                                        },
-                                    }),
-                                ],
-                            }),
-                        ],
-                    },
-                ],
-            });
-
-            // tslint:disable-next-line: no-string-literal
-            sinon.stub(compiler["imageReplacer"], "getMediaData").returns([
-                {
-                    stream: Buffer.from(""),
-                    fileName: "test",
-                    transformation: {
-                        pixels: {
-                            x: 100,
-                            y: 100,
-                        },
-                        emus: {
-                            x: 100,
-                            y: 100,
-                        },
-                    },
-                },
-            ]);
-
-            compiler.compile(file);
-        });
-    });
-});