docx 8.0.0 → 8.0.2

package/src/patcher/replacer.spec.ts

@@ -1,206 +0,0 @@
-import { IViewWrapper } from "@file/document-wrapper";
-import { File } from "@file/file";
-import { Paragraph, TextRun } from "@file/paragraph";
-import { IContext } from "@file/xml-components";
-import { expect } from "chai";
-import * as sinon from "sinon";
-
-import { PatchType } from "./from-docx";
-
-import { replacer } from "./replacer";
-
-const MOCK_JSON = {
-    elements: [
-        {
-            type: "element",
-            name: "w:hdr",
-            elements: [
-                {
-                    type: "element",
-                    name: "w:p",
-                    attributes: { "w14:paraId": "3BE1A671", "w14:textId": "74E856C4", "w:rsidR": "000D38A7", "w:rsidRDefault": "000D38A7" },
-                    elements: [
-                        {
-                            type: "element",
-                            name: "w:pPr",
-                            elements: [{ type: "element", name: "w:pStyle", attributes: { "w:val": "Header" } }],
-                        },
-                        {
-                            type: "element",
-                            name: "w:r",
-                            elements: [{ type: "element", name: "w:t", elements: [{ type: "text", text: "This is a {{head" }] }],
-                        },
-                        {
-                            type: "element",
-                            name: "w:r",
-                            attributes: { "w:rsidR": "004A3A99" },
-                            elements: [{ type: "element", name: "w:t", elements: [{ type: "text", text: "er" }] }],
-                        },
-                        {
-                            type: "element",
-                            name: "w:r",
-                            elements: [
-                                { type: "element", name: "w:t", elements: [{ type: "text", text: "_adjective}} don’t you think?" }] },
-                            ],
-                        },
-                    ],
-                },
-            ],
-        },
-    ],
-};
-
-describe("replacer", () => {
-    describe("replacer", () => {
-        it("should return the same object if nothing is added", () => {
-            const output = replacer(
-                {
-                    elements: [],
-                },
-                {
-                    type: PatchType.PARAGRAPH,
-                    children: [],
-                },
-                "hello",
-                [],
-                sinon.mock() as unknown as IContext,
-            );
-
-            expect(output).to.deep.equal({
-                elements: [],
-            });
-        });
-
-        it("should replace paragraph type", () => {
-            const output = replacer(
-                MOCK_JSON,
-                {
-                    type: PatchType.PARAGRAPH,
-                    children: [new TextRun("Delightful Header")],
-                },
-                "{{header_adjective}}",
-                [
-                    {
-                        text: "This is a {{header_adjective}} don’t you think?",
-                        runs: [
-                            {
-                                text: "This is a {{head",
-                                parts: [{ text: "This is a {{head", index: 0, start: 0, end: 15 }],
-                                index: 1,
-                                start: 0,
-                                end: 15,
-                            },
-                            { text: "er", parts: [{ text: "er", index: 0, start: 16, end: 17 }], index: 2, start: 16, end: 17 },
-                            {
-                                text: "_adjective}} don’t you think?",
-                                parts: [{ text: "_adjective}} don’t you think?", index: 0, start: 18, end: 46 }],
-                                index: 3,
-                                start: 18,
-                                end: 46,
-                            },
-                        ],
-                        index: 0,
-                        path: [0, 0, 0],
-                    },
-                ],
-                {
-                    file: {} as unknown as File,
-                    viewWrapper: {
-                        Relationships: {},
-                    } as unknown as IViewWrapper,
-                    stack: [],
-                },
-            );
-
-            expect(JSON.stringify(output)).to.contain("Delightful Header");
-        });
-
-        it("should replace document type", () => {
-            const output = replacer(
-                MOCK_JSON,
-                {
-                    type: PatchType.DOCUMENT,
-                    children: [new Paragraph("Lorem ipsum paragraph")],
-                },
-                "{{header_adjective}}",
-                [
-                    {
-                        text: "This is a {{header_adjective}} don’t you think?",
-                        runs: [
-                            {
-                                text: "This is a {{head",
-                                parts: [{ text: "This is a {{head", index: 0, start: 0, end: 15 }],
-                                index: 1,
-                                start: 0,
-                                end: 15,
-                            },
-                            { text: "er", parts: [{ text: "er", index: 0, start: 16, end: 17 }], index: 2, start: 16, end: 17 },
-                            {
-                                text: "_adjective}} don’t you think?",
-                                parts: [{ text: "_adjective}} don’t you think?", index: 0, start: 18, end: 46 }],
-                                index: 3,
-                                start: 18,
-                                end: 46,
-                            },
-                        ],
-                        index: 0,
-                        path: [0, 0, 0],
-                    },
-                ],
-                {
-                    file: {} as unknown as File,
-                    viewWrapper: {
-                        Relationships: {},
-                    } as unknown as IViewWrapper,
-                    stack: [],
-                },
-            );
-
-            expect(JSON.stringify(output)).to.contain("Lorem ipsum paragraph");
-        });
-
-        it("should throw an error if the type is not supported", () => {
-            expect(() =>
-                replacer(
-                    {},
-                    {
-                        type: PatchType.DOCUMENT,
-                        children: [new Paragraph("Lorem ipsum paragraph")],
-                    },
-                    "{{header_adjective}}",
-                    [
-                        {
-                            text: "This is a {{header_adjective}} don’t you think?",
-                            runs: [
-                                {
-                                    text: "This is a {{head",
-                                    parts: [{ text: "This is a {{head", index: 0, start: 0, end: 15 }],
-                                    index: 1,
-                                    start: 0,
-                                    end: 15,
-                                },
-                                { text: "er", parts: [{ text: "er", index: 0, start: 16, end: 17 }], index: 2, start: 16, end: 17 },
-                                {
-                                    text: "_adjective}} don’t you think?",
-                                    parts: [{ text: "_adjective}} don’t you think?", index: 0, start: 18, end: 46 }],
-                                    index: 3,
-                                    start: 18,
-                                    end: 46,
-                                },
-                            ],
-                            index: 0,
-                            path: [0, 0, 0],
-                        },
-                    ],
-                    {
-                        file: {} as unknown as File,
-                        viewWrapper: {
-                            Relationships: {},
-                        } as unknown as IViewWrapper,
-                        stack: [],
-                    },
-                ),
-            ).to.throw();
-        });
-    });
-});

package/src/patcher/replacer.ts

@@ -1,83 +0,0 @@
-import { Element } from "xml-js";
-import * as xml from "xml";
-
-import { Formatter } from "@export/formatter";
-import { IContext, XmlComponent } from "@file/xml-components";
-
-import { IPatch, PatchType } from "./from-docx";
-import { toJson } from "./util";
-import { IRenderedParagraphNode } from "./run-renderer";
-import { replaceTokenInParagraphElement } from "./paragraph-token-replacer";
-import { findRunElementIndexWithToken, splitRunElement } from "./paragraph-split-inject";
-
-const formatter = new Formatter();
-
-const SPLIT_TOKEN = "ɵ";
-
-export const replacer = (
-    json: Element,
-    patch: IPatch,
-    patchText: string,
-    renderedParagraphs: readonly IRenderedParagraphNode[],
-    context: IContext,
-): Element => {
-    for (const renderedParagraph of renderedParagraphs) {
-        const textJson = patch.children
-            // eslint-disable-next-line no-loop-func
-            .map((c) => toJson(xml(formatter.format(c as XmlComponent, context))))
-            .map((c) => c.elements![0]);
-
-        switch (patch.type) {
-            case PatchType.DOCUMENT: {
-                const parentElement = goToParentElementFromPath(json, renderedParagraph.path);
-                const elementIndex = getLastElementIndexFromPath(renderedParagraph.path);
-                // eslint-disable-next-line functional/immutable-data, prefer-destructuring
-                parentElement.elements!.splice(elementIndex, 1, ...textJson);
-                break;
-            }
-            case PatchType.PARAGRAPH:
-            default: {
-                const paragraphElement = goToElementFromPath(json, renderedParagraph.path);
-                replaceTokenInParagraphElement({
-                    paragraphElement,
-                    renderedParagraph,
-                    originalText: patchText,
-                    replacementText: SPLIT_TOKEN,
-                });
-
-                const index = findRunElementIndexWithToken(paragraphElement, SPLIT_TOKEN);
-
-                const { left, right } = splitRunElement(paragraphElement.elements![index], SPLIT_TOKEN);
-                // eslint-disable-next-line functional/immutable-data
-                paragraphElement.elements!.splice(index, 1, left, ...textJson, right);
-                break;
-            }
-        }
-    }
-
-    return json;
-};
-
-const goToElementFromPath = (json: Element, path: readonly number[]): Element => {
-    let element = json;
-
-    // We start from 1 because the first element is the root element
-    // Which we do not want to double count
-    for (let i = 1; i < path.length; i++) {
-        const index = path[i];
-        const nextElements = element.elements;
-
-        if (!nextElements) {
-            throw new Error("Could not find element");
-        }
-
-        element = nextElements[index];
-    }
-
-    return element;
-};
-
-const goToParentElementFromPath = (json: Element, path: readonly number[]): Element =>
-    goToElementFromPath(json, path.slice(0, path.length - 1));
-
-const getLastElementIndexFromPath = (path: readonly number[]): number => path[path.length - 1];

package/src/patcher/run-renderer.spec.ts

@@ -1,96 +0,0 @@
-import { expect } from "chai";
-import { renderParagraphNode } from "./run-renderer";
-
-describe("run-renderer", () => {
-    describe("renderParagraphNode", () => {
-        it("should return a rendered paragraph node if theres no elements", () => {
-            const output = renderParagraphNode({ element: { name: "w:p" }, index: 0, parent: undefined });
-            expect(output).to.deep.equal({
-                index: -1,
-                path: [],
-                runs: [],
-                text: "",
-            });
-        });
-
-        it("should return a rendered paragraph node if there are elements", () => {
-            const output = renderParagraphNode({
-                element: {
-                    name: "w:p",
-                    elements: [
-                        {
-                            name: "w:r",
-                            elements: [
-                                {
-                                    name: "w:t",
-                                    elements: [
-                                        {
-                                            type: "text",
-                                            text: "hello",
-                                        },
-                                    ],
-                                },
-                            ],
-                        },
-                    ],
-                },
-                index: 0,
-                parent: undefined,
-            });
-            expect(output).to.deep.equal({
-                index: 0,
-                path: [0],
-                runs: [
-                    {
-                        end: 4,
-                        index: 0,
-                        parts: [
-                            {
-                                end: 4,
-                                index: 0,
-                                start: 0,
-                                text: "hello",
-                            },
-                        ],
-                        start: 0,
-                        text: "hello",
-                    },
-                ],
-                text: "hello",
-            });
-        });
-
-        it("should throw an error if the element is not a paragraph", () => {
-            expect(() => renderParagraphNode({ element: { name: "w:r" }, index: 0, parent: undefined })).to.throw();
-        });
-
-        it("should return blank defaults if run is empty", () => {
-            const output = renderParagraphNode({
-                element: {
-                    name: "w:p",
-                    elements: [
-                        {
-                            name: "w:r",
-                        },
-                    ],
-                },
-                index: 0,
-                parent: undefined,
-            });
-            expect(output).to.deep.equal({
-                index: 0,
-                path: [0],
-                runs: [
-                    {
-                        end: 0,
-                        index: -1,
-                        parts: [],
-                        start: 0,
-                        text: "",
-                    },
-                ],
-                text: "",
-            });
-        });
-    });
-});

package/src/patcher/run-renderer.ts

@@ -1,109 +0,0 @@
-import { Element } from "xml-js";
-
-import { ElementWrapper } from "./traverser";
-
-export interface IRenderedParagraphNode {
-    readonly text: string;
-    readonly runs: readonly IRenderedRunNode[];
-    readonly index: number;
-    readonly path: readonly number[];
-}
-
-interface StartAndEnd {
-    readonly start: number;
-    readonly end: number;
-}
-
-type IParts = {
-    readonly text: string;
-    readonly index: number;
-} & StartAndEnd;
-
-export type IRenderedRunNode = {
-    readonly text: string;
-    readonly parts: readonly IParts[];
-    readonly index: number;
-} & StartAndEnd;
-
-export const renderParagraphNode = (node: ElementWrapper): IRenderedParagraphNode => {
-    if (node.element.name !== "w:p") {
-        throw new Error(`Invalid node type: ${node.element.name}`);
-    }
-
-    if (!node.element.elements) {
-        return {
-            text: "",
-            runs: [],
-            index: -1,
-            path: [],
-        };
-    }
-
-    let currentRunStringLength = 0;
-
-    const runs = node.element.elements
-        .map((element, i) => ({ element, i }))
-        .filter(({ element }) => element.name === "w:r")
-        .map(({ element, i }) => {
-            const renderedRunNode = renderRunNode(element, i, currentRunStringLength);
-            currentRunStringLength += renderedRunNode.text.length;
-
-            return renderedRunNode;
-        })
-        .filter((e) => !!e)
-        .map((e) => e as IRenderedRunNode);
-
-    const text = runs.reduce((acc, curr) => acc + curr.text, "");
-
-    return {
-        text,
-        runs,
-        index: node.index,
-        path: buildNodePath(node),
-    };
-};
-
-const renderRunNode = (node: Element, index: number, currentRunStringIndex: number): IRenderedRunNode => {
-    if (!node.elements) {
-        return {
-            text: "",
-            parts: [],
-            index: -1,
-            start: currentRunStringIndex,
-            end: currentRunStringIndex,
-        };
-    }
-
-    let currentTextStringIndex = currentRunStringIndex;
-
-    const parts = node.elements
-        .map((element, i: number) =>
-            element.name === "w:t" && element.elements && element.elements.length > 0
-                ? {
-                      text: element.elements[0].text?.toString() ?? "",
-                      index: i,
-                      start: currentTextStringIndex,
-                      end: (() => {
-                          // Side effect
-                          currentTextStringIndex += (element.elements[0].text?.toString() ?? "").length - 1;
-                          return currentTextStringIndex;
-                      })(),
-                  }
-                : undefined,
-        )
-        .filter((e) => !!e)
-        .map((e) => e as IParts);
-
-    const text = parts.reduce((acc, curr) => acc + curr.text, "");
-
-    return {
-        text,
-        parts,
-        index,
-        start: currentRunStringIndex,
-        end: currentTextStringIndex,
-    };
-};
-
-const buildNodePath = (node: ElementWrapper): readonly number[] =>
-    node.parent ? [...buildNodePath(node.parent), node.index] : [node.index];