docx 7.8.2 → 8.0.0

package/src/patcher/replacer.spec.ts

@@ -0,0 +1,206 @@
+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

@@ -0,0 +1,83 @@
+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

@@ -0,0 +1,96 @@
+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

@@ -0,0 +1,109 @@
+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];