docx 8.0.0 → 8.0.1

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

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

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

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

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

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

@@ -1,42 +0,0 @@
-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;
-};