docx 7.8.2 → 8.0.0

package/src/patcher/paragraph-split-inject.spec.ts

@@ -0,0 +1,224 @@
+import { expect } from "chai";
+
+import { findRunElementIndexWithToken, splitRunElement } from "./paragraph-split-inject";
+
+describe("paragraph-split-inject", () => {
+    describe("findRunElementIndexWithToken", () => {
+        it("should find the index of a run element with a token", () => {
+            const output = findRunElementIndexWithToken(
+                {
+                    name: "w:p",
+                    type: "element",
+                    elements: [
+                        {
+                            name: "w:r",
+                            type: "element",
+                            elements: [
+                                {
+                                    name: "w:t",
+                                    type: "element",
+                                    elements: [
+                                        {
+                                            type: "text",
+                                            text: "hello world",
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                    ],
+                },
+                "hello",
+            );
+            expect(output).to.deep.equal(0);
+        });
+
+        it("should throw an exception when ran with empty elements", () => {
+            expect(() =>
+                findRunElementIndexWithToken(
+                    {
+                        name: "w:p",
+                        type: "element",
+                    },
+                    "hello",
+                ),
+            ).to.throw();
+        });
+
+        it("should throw an exception when ran with empty elements", () => {
+            expect(() =>
+                findRunElementIndexWithToken(
+                    {
+                        name: "w:p",
+                        type: "element",
+                        elements: [
+                            {
+                                name: "w:r",
+                                type: "element",
+                            },
+                        ],
+                    },
+                    "hello",
+                ),
+            ).to.throw();
+        });
+
+        it("should throw an exception when ran with empty elements", () => {
+            expect(() =>
+                findRunElementIndexWithToken(
+                    {
+                        name: "w:p",
+                        type: "element",
+                        elements: [
+                            {
+                                name: "w:r",
+                                type: "element",
+                                elements: [
+                                    {
+                                        name: "w:t",
+                                        type: "element",
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                    "hello",
+                ),
+            ).to.throw();
+        });
+    });
+
+    describe("splitRunElement", () => {
+        it("should split a run element", () => {
+            const output = splitRunElement(
+                {
+                    name: "w:r",
+                    type: "element",
+                    elements: [
+                        {
+                            name: "w:t",
+                            type: "element",
+                            elements: [
+                                {
+                                    type: "text",
+                                    text: "hello*world",
+                                },
+                            ],
+                        },
+                        {
+                            name: "w:x",
+                            type: "element",
+                        },
+                    ],
+                },
+                "*",
+            );
+
+            expect(output).to.deep.equal({
+                left: {
+                    elements: [
+                        {
+                            attributes: {
+                                "xml:space": "preserve",
+                            },
+                            elements: [
+                                {
+                                    text: "hello",
+                                    type: "text",
+                                },
+                            ],
+                            name: "w:t",
+                            type: "element",
+                        },
+                    ],
+                    name: "w:r",
+                    type: "element",
+                },
+                right: {
+                    elements: [
+                        {
+                            attributes: {
+                                "xml:space": "preserve",
+                            },
+                            elements: [
+                                {
+                                    text: "world",
+                                    type: "text",
+                                },
+                            ],
+                            name: "w:t",
+                            type: "element",
+                        },
+                        {
+                            name: "w:x",
+                            type: "element",
+                        },
+                    ],
+                    name: "w:r",
+                    type: "element",
+                },
+            });
+        });
+
+        it("should try to split even if elements is empty for text", () => {
+            const output = splitRunElement(
+                {
+                    name: "w:r",
+                    type: "element",
+                    elements: [
+                        {
+                            name: "w:t",
+                            type: "element",
+                        },
+                    ],
+                },
+                "*",
+            );
+
+            expect(output).to.deep.equal({
+                left: {
+                    elements: [
+                        {
+                            attributes: {
+                                "xml:space": "preserve",
+                            },
+                            elements: [],
+                            name: "w:t",
+                            type: "element",
+                        },
+                    ],
+                    name: "w:r",
+                    type: "element",
+                },
+                right: {
+                    elements: [],
+                    name: "w:r",
+                    type: "element",
+                },
+            });
+        });
+
+        it("should return empty elements", () => {
+            const output = splitRunElement(
+                {
+                    name: "w:r",
+                    type: "element",
+                },
+                "*",
+            );
+
+            expect(output).to.deep.equal({
+                left: {
+                    elements: [],
+                    name: "w:r",
+                    type: "element",
+                },
+                right: {
+                    elements: [],
+                    name: "w:r",
+                    type: "element",
+                },
+            });
+        });
+    });
+});

package/src/patcher/paragraph-split-inject.ts

@@ -0,0 +1,54 @@
+import { Element } from "xml-js";
+import { createTextElementContents, patchSpaceAttribute } from "./util";
+
+export const findRunElementIndexWithToken = (paragraphElement: Element, token: string): number => {
+    for (let i = 0; i < (paragraphElement.elements ?? []).length; i++) {
+        const element = paragraphElement.elements![i];
+        if (element.type === "element" && element.name === "w:r") {
+            const textElement = (element.elements ?? []).filter((e) => e.type === "element" && e.name === "w:t");
+
+            for (const text of textElement) {
+                if ((text.elements?.[0].text as string)?.includes(token)) {
+                    return i;
+                }
+            }
+        }
+    }
+
+    throw new Error("Token not found");
+};
+
+export const splitRunElement = (runElement: Element, token: string): { readonly left: Element; readonly right: Element } => {
+    let splitIndex = 0;
+
+    const splitElements =
+        runElement.elements
+            ?.map((e, i) => {
+                if (e.type === "element" && e.name === "w:t") {
+                    const text = (e.elements?.[0].text as string) ?? "";
+                    const splitText = text.split(token);
+                    const newElements = splitText.map((t) => ({
+                        ...e,
+                        ...patchSpaceAttribute(e),
+                        elements: createTextElementContents(t),
+                    }));
+                    splitIndex = i;
+                    return newElements;
+                } else {
+                    return e;
+                }
+            })
+            .flat() ?? [];
+
+    const leftRunElement: Element = {
+        ...JSON.parse(JSON.stringify(runElement)),
+        elements: splitElements.slice(0, splitIndex + 1),
+    };
+
+    const rightRunElement: Element = {
+        ...JSON.parse(JSON.stringify(runElement)),
+        elements: splitElements.slice(splitIndex + 1),
+    };
+
+    return { left: leftRunElement, right: rightRunElement };
+};

package/src/patcher/paragraph-token-replacer.spec.ts

@@ -0,0 +1,165 @@
+import { expect } from "chai";
+
+import { replaceTokenInParagraphElement } from "./paragraph-token-replacer";
+
+describe("paragraph-token-replacer", () => {
+    describe("replaceTokenInParagraphElement", () => {
+        it("should replace token in paragraph", () => {
+            const output = replaceTokenInParagraphElement({
+                paragraphElement: {
+                    name: "w:p",
+                    elements: [
+                        {
+                            name: "w:r",
+                            elements: [
+                                {
+                                    name: "w:t",
+                                    elements: [
+                                        {
+                                            type: "text",
+                                            text: "hello",
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                    ],
+                },
+                renderedParagraph: {
+                    index: 0,
+                    path: [0],
+                    runs: [
+                        {
+                            end: 4,
+                            index: 0,
+                            parts: [
+                                {
+                                    end: 4,
+                                    index: 0,
+                                    start: 0,
+                                    text: "hello",
+                                },
+                            ],
+                            start: 0,
+                            text: "hello",
+                        },
+                    ],
+                    text: "hello",
+                },
+                originalText: "hello",
+                replacementText: "world",
+            });
+
+            expect(output).to.deep.equal({
+                elements: [
+                    {
+                        elements: [
+                            {
+                                elements: [
+                                    {
+                                        text: "world",
+                                        type: "text",
+                                    },
+                                ],
+                                name: "w:t",
+                            },
+                        ],
+                        name: "w:r",
+                    },
+                ],
+                name: "w:p",
+            });
+        });
+
+        // Try to fill rest of test coverage
+        // it("should replace token in paragraph", () => {
+        //     const output = replaceTokenInParagraphElement({
+        //         paragraphElement: {
+        //             name: "w:p",
+        //             elements: [
+        //                 {
+        //                     name: "w:r",
+        //                     elements: [
+        //                         {
+        //                             name: "w:t",
+        //                             elements: [
+        //                                 {
+        //                                     type: "text",
+        //                                     text: "test ",
+        //                                 },
+        //                             ],
+        //                         },
+        //                         {
+        //                             name: "w:t",
+        //                             elements: [
+        //                                 {
+        //                                     type: "text",
+        //                                     text: " hello ",
+        //                                 },
+        //                             ],
+        //                         },
+        //                     ],
+        //                 },
+        //             ],
+        //         },
+        //         renderedParagraph: {
+        //             index: 0,
+        //             path: [0],
+        //             runs: [
+        //                 {
+        //                     end: 4,
+        //                     index: 0,
+        //                     parts: [
+        //                         {
+        //                             end: 4,
+        //                             index: 0,
+        //                             start: 0,
+        //                             text: "test ",
+        //                         },
+        //                     ],
+        //                     start: 0,
+        //                     text: "test ",
+        //                 },
+        //                 {
+        //                     end: 10,
+        //                     index: 0,
+        //                     parts: [
+        //                         {
+        //                             end: 10,
+        //                             index: 0,
+        //                             start: 5,
+        //                             text: "hello ",
+        //                         },
+        //                     ],
+        //                     start: 5,
+        //                     text: "hello ",
+        //                 },
+        //             ],
+        //             text: "test hello ",
+        //         },
+        //         originalText: "hello",
+        //         replacementText: "world",
+        //     });
+
+        //     expect(output).to.deep.equal({
+        //         elements: [
+        //             {
+        //                 elements: [
+        //                     {
+        //                         elements: [
+        //                             {
+        //                                 text: "test world ",
+        //                                 type: "text",
+        //                             },
+        //                         ],
+        //                         name: "w:t",
+        //                     },
+        //                 ],
+        //                 name: "w:r",
+        //             },
+        //         ],
+        //         name: "w:p",
+        //     });
+        // });
+    });
+});

package/src/patcher/paragraph-token-replacer.ts

@@ -0,0 +1,69 @@
+import { Element } from "xml-js";
+
+import { createTextElementContents, patchSpaceAttribute } from "./util";
+import { IRenderedParagraphNode } from "./run-renderer";
+
+enum ReplaceMode {
+    START,
+    MIDDLE,
+    END,
+}
+
+export const replaceTokenInParagraphElement = ({
+    paragraphElement,
+    renderedParagraph,
+    originalText,
+    replacementText,
+}: {
+    readonly paragraphElement: Element;
+    readonly renderedParagraph: IRenderedParagraphNode;
+    readonly originalText: string;
+    readonly replacementText: string;
+}): Element => {
+    const startIndex = renderedParagraph.text.indexOf(originalText);
+    const endIndex = startIndex + originalText.length - 1;
+
+    let replaceMode = ReplaceMode.START;
+
+    for (const run of renderedParagraph.runs) {
+        for (const { text, index, start, end } of run.parts) {
+            switch (replaceMode) {
+                case ReplaceMode.START:
+                    if (startIndex >= start) {
+                        const partToReplace = run.text.substring(Math.max(startIndex, start), Math.min(endIndex, end) + 1);
+                        // We use a token to split the text if the replacement is within the same run
+                        // If not, we just add text to the middle of the run later
+                        const firstPart = text.replace(partToReplace, replacementText);
+                        patchTextElement(paragraphElement.elements![run.index].elements![index], firstPart);
+                        replaceMode = ReplaceMode.MIDDLE;
+                        continue;
+                    }
+                    break;
+                case ReplaceMode.MIDDLE:
+                    if (endIndex <= end) {
+                        const lastPart = text.substring(endIndex - start + 1);
+                        patchTextElement(paragraphElement.elements![run.index].elements![index], lastPart);
+                        const currentElement = paragraphElement.elements![run.index].elements![index];
+                        // We need to add xml:space="preserve" to the last element to preserve the whitespace
+                        // Otherwise, the text will be merged with the next element
+                        // eslint-disable-next-line functional/immutable-data
+                        paragraphElement.elements![run.index].elements![index] = patchSpaceAttribute(currentElement);
+                        replaceMode = ReplaceMode.END;
+                    } else {
+                        patchTextElement(paragraphElement.elements![run.index].elements![index], "");
+                    }
+                    break;
+                default:
+            }
+        }
+    }
+
+    return paragraphElement;
+};
+
+const patchTextElement = (element: Element, text: string): Element => {
+    // eslint-disable-next-line functional/immutable-data
+    element.elements = createTextElementContents(text);
+
+    return element;
+};

package/src/patcher/relationship-manager.spec.ts

@@ -0,0 +1,87 @@
+import { TargetModeType } from "@file/relationships/relationship/relationship";
+import { expect } from "chai";
+
+import { appendRelationship, getNextRelationshipIndex } from "./relationship-manager";
+
+describe("relationship-manager", () => {
+    describe("getNextRelationshipIndex", () => {
+        it("should get next relationship index", () => {
+            const output = getNextRelationshipIndex({
+                elements: [
+                    {
+                        type: "element",
+                        name: "Relationships",
+                        elements: [
+                            { type: "element", attributes: { Id: "rId1" }, name: "Relationship" },
+                            { type: "element", attributes: { Id: "rId1" }, name: "Relationship" },
+                        ],
+                    },
+                ],
+            });
+            expect(output).to.deep.equal(2);
+        });
+
+        it("should work with an empty relationship Id", () => {
+            const output = getNextRelationshipIndex({
+                elements: [
+                    {
+                        type: "element",
+                        name: "Relationships",
+                        elements: [{ type: "element", name: "Relationship" }],
+                    },
+                ],
+            });
+            expect(output).to.deep.equal(1);
+        });
+
+        it("should work with no relationships", () => {
+            const output = getNextRelationshipIndex({
+                elements: [
+                    {
+                        type: "element",
+                        name: "Relationships",
+                        elements: [],
+                    },
+                ],
+            });
+            expect(output).to.deep.equal(1);
+        });
+    });
+
+    describe("appendRelationship", () => {
+        it("should append a relationship", () => {
+            const output = appendRelationship(
+                {
+                    elements: [
+                        {
+                            type: "element",
+                            name: "Relationships",
+                            elements: [
+                                { type: "element", attributes: { Id: "rId1" }, name: "Relationship" },
+                                { type: "element", attributes: { Id: "rId1" }, name: "Relationship" },
+                            ],
+                        },
+                    ],
+                },
+                1,
+                "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
+                "test",
+                TargetModeType.EXTERNAL,
+            );
+            expect(output).to.deep.equal([
+                { type: "element", attributes: { Id: "rId1" }, name: "Relationship" },
+                { type: "element", attributes: { Id: "rId1" }, name: "Relationship" },
+                {
+                    attributes: {
+                        Id: "rId1",
+                        Type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
+                        TargetMode: TargetModeType.EXTERNAL,
+                        Target: "test",
+                    },
+                    name: "Relationship",
+                    type: "element",
+                },
+            ]);
+        });
+    });
+});

package/src/patcher/relationship-manager.ts

@@ -0,0 +1,42 @@
+import { Element } from "xml-js";
+
+import { RelationshipType, TargetModeType } from "@file/relationships/relationship/relationship";
+import { getFirstLevelElements } from "./util";
+
+const getIdFromRelationshipId = (relationshipId: string): number => {
+    const output = parseInt(relationshipId.substring(3), 10);
+    return isNaN(output) ? 0 : output;
+};
+
+export const getNextRelationshipIndex = (relationships: Element): number => {
+    const relationshipElements = getFirstLevelElements(relationships, "Relationships");
+
+    return (
+        relationshipElements
+            .map((e) => getIdFromRelationshipId(e.attributes?.Id?.toString() ?? ""))
+            .reduce((acc, curr) => Math.max(acc, curr), 0) + 1
+    );
+};
+
+export const appendRelationship = (
+    relationships: Element,
+    id: number | string,
+    type: RelationshipType,
+    target: string,
+    targetMode?: TargetModeType,
+): readonly Element[] => {
+    const relationshipElements = getFirstLevelElements(relationships, "Relationships");
+    // eslint-disable-next-line functional/immutable-data
+    relationshipElements.push({
+        attributes: {
+            Id: `rId${id}`,
+            Type: type,
+            Target: target,
+            TargetMode: targetMode,
+        },
+        name: "Relationship",
+        type: "element",
+    });
+
+    return relationshipElements;
+};