easy-template-x 6.2.2 → 7.0.0

package/src/compilation/delimiters/attributesDelimiterSearcher.ts

@@ -0,0 +1,109 @@
+import { TagPlacement } from "src/compilation/tag";
+import { tagRegex } from "src/compilation/tagUtils";
+import { Delimiters } from "src/delimiters";
+import { InternalArgumentMissingError } from "src/errors";
+import { OmlNode } from "src/office";
+import { xml, XmlGeneralNode, XmlNode, XmlTreeIterator } from "src/xml";
+import { AttributeDelimiterMark, DelimiterMark } from "./delimiterMark";
+
+const drawingDescriptionAttributeName = "descr";
+
+export class AttributesDelimiterSearcher {
+
+    private readonly visitedNodes: Set<XmlNode> = new Set();
+
+    private readonly delimiters: Delimiters;
+    private readonly tagRegex: RegExp;
+
+    constructor(delimiters: Delimiters) {
+        if (!delimiters)
+            throw new InternalArgumentMissingError("delimiters");
+
+        this.delimiters = delimiters;
+        this.tagRegex = tagRegex(delimiters, true);
+    }
+
+    public processNode(it: XmlTreeIterator, delimiters: DelimiterMark[]): void {
+
+        // Ignore irrelevant nodes
+        if (!this.shouldSearchNode(it)) {
+            return;
+        }
+
+        // Search delimiters in attributes
+        this.findDelimiters(it, delimiters);
+    }
+
+    private shouldSearchNode(it: XmlTreeIterator): it is XmlTreeIterator<XmlGeneralNode> {
+
+        if (this.visitedNodes.has(it.node)) {
+            return false;
+        }
+        this.visitedNodes.add(it.node);
+
+        if (!xml.query.isGeneralNode(it.node))
+            return false;
+        if (Object.keys(it.node.attributes || {}).length === 0)
+            return false;
+
+        // Currently we only support description attributes of drawing objects
+        if (!this.isDrawingPropertiesNode(it.node)) {
+            return false;
+        }
+        if (!it.node.attributes[drawingDescriptionAttributeName]) {
+            return false;
+        }
+
+        return true;
+    }
+
+    private isDrawingPropertiesNode(node: XmlGeneralNode): boolean {
+
+        // Node is drawing properties
+        if (node.nodeName !== OmlNode.Wp.DocPr) {
+            return false;
+        }
+
+        // Parent is drawing
+        if (!node.parentNode) {
+            return false;
+        }
+        const parent = xml.query.findParentByName(node, OmlNode.W.Drawing);
+        return !!parent;
+    }
+
+    private findDelimiters(it: XmlTreeIterator<XmlGeneralNode>, delimiters: DelimiterMark[]): void {
+
+        // Currently we only support description attributes of drawing objects
+        this.findDelimitersInAttribute(it.node, drawingDescriptionAttributeName, delimiters);
+    }
+
+    private findDelimitersInAttribute(node: XmlGeneralNode, attributeName: string, delimiters: DelimiterMark[]): void {
+        const attrValue = node.attributes?.[attributeName];
+        if (!attrValue) {
+            return;
+        }
+
+        const matches = attrValue.matchAll(this.tagRegex);
+        for (const match of matches) {
+            const tag = match[0];
+            const openDelimiterIndex = match.index;
+            const closeDelimiterIndex = openDelimiterIndex + tag.length - this.delimiters.tagEnd.length;
+
+            const openDelimiter = this.createCurrentDelimiterMark(openDelimiterIndex, true, node, attributeName);
+            const closeDelimiter = this.createCurrentDelimiterMark(closeDelimiterIndex, false, node, attributeName);
+            delimiters.push(openDelimiter);
+            delimiters.push(closeDelimiter);
+        }
+    }
+
+    private createCurrentDelimiterMark(index: number, isOpen: boolean, xmlNode: XmlGeneralNode, attributeName: string): AttributeDelimiterMark {
+        return {
+            placement: TagPlacement.Attribute,
+            isOpen: isOpen,
+            index: index,
+            attributeName: attributeName,
+            xmlNode: xmlNode,
+        };
+    }
+}

package/src/compilation/delimiters/delimiterMark.ts

@@ -0,0 +1,32 @@
+import { OpenXmlPart } from "src/office";
+import { XmlGeneralNode, XmlTextNode } from "src/xml";
+import { TagPlacement } from "src/compilation/tag";
+
+export type DelimiterMark = TextNodeDelimiterMark | AttributeDelimiterMark;
+
+export interface BaseDelimiterMark {
+    openXmlPart?: OpenXmlPart;    
+    /**
+     * Is this an open delimiter or a close delimiter
+     */
+    isOpen: boolean;
+}
+
+export interface TextNodeDelimiterMark extends BaseDelimiterMark {
+    placement: typeof TagPlacement.TextNode;
+    xmlTextNode: XmlTextNode;
+    /**
+     * Index inside the text node
+     */
+    index: number;
+}
+
+export interface AttributeDelimiterMark extends BaseDelimiterMark {
+    placement: typeof TagPlacement.Attribute;
+    xmlNode: XmlGeneralNode;
+    attributeName: string;
+    /**
+     * Index inside the attribute
+     */
+    index: number;
+}

package/src/compilation/delimiters/delimiterSearcher.tests.ts

@@ -0,0 +1,571 @@
+import { DelimiterMark, DelimiterSearcher, TagPlacement } from "src/compilation";
+import { Delimiters } from "src/delimiters";
+import { xml, XmlNodeType } from "src/xml";
+import { parseXml } from "test/testUtils";
+import { describe, expect, test } from "vitest";
+
+describe(DelimiterSearcher, () => {
+
+    describe('single character delimiters', () => {
+
+        test('simple paragraph', () => {
+
+            const paragraph = parseXml(`
+                <w:p>
+                    <w:r>
+                        <w:t>{#loop}{/loop}</w:t>
+                    </w:r>
+                </w:p>
+            `);
+
+            const textNode = xml.query.findByPath(paragraph, XmlNodeType.Text, 0, 0, 0);
+            const expected: DelimiterMark[] = [
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: true,
+                    index: 0,
+                    xmlTextNode: textNode
+                },
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: false,
+                    index: 6,
+                    xmlTextNode: textNode
+                },
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: true,
+                    index: 7,
+                    xmlTextNode: textNode
+                },
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: false,
+                    index: 13,
+                    xmlTextNode: textNode
+                }
+            ];
+
+            const searcher = createDelimiterSearcher({
+                tagStart: '{',
+                tagEnd: '}'
+            });
+            const delimiters = searcher.findDelimiters(paragraph);
+
+            expect(delimiters).toEqual(expected);
+        });
+
+        test('two different text nodes', () => {
+
+            const paragraph = parseXml(`
+                <w:p>
+                    <w:r>
+                        <w:t>{#lo</w:t>
+                        <w:t>op}</w:t>
+                    </w:r>
+                </w:p>
+            `);
+
+            const firstTextNode = xml.query.findByPath(paragraph, XmlNodeType.Text, 0, 0, 0);
+            const secondTextNode = xml.query.findByPath(paragraph, XmlNodeType.Text, 0, 1, 0);
+            const expected: DelimiterMark[] = [
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: true,
+                    index: 0,
+                    xmlTextNode: firstTextNode
+                },
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: false,
+                    index: 2,
+                    xmlTextNode: secondTextNode
+                }
+            ];
+
+            const searcher = createDelimiterSearcher({
+                tagStart: '{',
+                tagEnd: '}'
+            });
+            const delimiters = searcher.findDelimiters(paragraph);
+
+            expect(delimiters).toEqual(expected);
+        });
+
+        test('two different run nodes', () => {
+
+            const paragraph = parseXml(`
+                <w:p>
+                    <w:r>
+                        <w:t>{</w:t>
+                    </w:r>
+                    <w:r>
+                        <w:t>tag</w:t>
+                    </w:r>
+                    <w:r>
+                        <w:t>}</w:t>
+                    </w:r>
+                </w:p>
+            `);
+
+            const firstTextNode = xml.query.findByPath(paragraph, XmlNodeType.Text, 0, 0, 0);
+            const thirdTextNode = xml.query.findByPath(paragraph, XmlNodeType.Text, 2, 0, 0);
+            const expected: DelimiterMark[] = [
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: true,
+                    index: 0,
+                    xmlTextNode: firstTextNode
+                },
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: false,
+                    index: 0,
+                    xmlTextNode: thirdTextNode
+                }
+            ];
+
+            const searcher = createDelimiterSearcher({
+                tagStart: '{',
+                tagEnd: '}'
+            });
+            const delimiters = searcher.findDelimiters(paragraph);
+
+            expect(delimiters).toEqual(expected);
+        });
+
+        test("inline drawing in the middle of a tag", () => {
+            const paragraph = parseXml(`
+                <w:p>
+                    <w:r>
+                        <w:t xml:space="preserve">{Text </w:t>
+                    </w:r>
+                    <w:r>
+                        <w:drawing>
+                            <wp:inline>
+                                <wp:docPr descr="{Attribute Tag}"/>
+                            </wp:inline>
+                        </w:drawing>
+                    </w:r>
+                    <w:r>
+                        <w:t>Tag}</w:t>
+                    </w:r>
+                </w:p>
+            `, false);
+
+            const openTextNode = xml.query.findByPath(paragraph, XmlNodeType.Text, 0, 0, 0);
+            const closeTextNode = xml.query.findByPath(paragraph, XmlNodeType.Text, 2, 0, 0);
+            const imagePropertiesNode = xml.query.findByPath(paragraph, XmlNodeType.General, 1, 0, 0, 0);
+            const expected: DelimiterMark[] = [
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: true,
+                    index: 0,
+                    xmlTextNode: openTextNode
+                },
+                {
+                    placement: TagPlacement.Attribute,
+                    isOpen: true,
+                    index: 0,
+                    xmlNode: imagePropertiesNode,
+                    attributeName: 'descr'
+                },
+                {
+                    placement: TagPlacement.Attribute,
+                    isOpen: false,
+                    index: 14,
+                    xmlNode: imagePropertiesNode,
+                    attributeName: 'descr'
+                },
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: false,
+                    index: 3,
+                    xmlTextNode: closeTextNode
+                },
+            ];
+
+            const searcher = createDelimiterSearcher({
+                tagStart: '{',
+                tagEnd: '}'
+            });
+
+            const delimiters = searcher.findDelimiters(paragraph);
+            expect(delimiters).toEqual(expected);
+        });
+    });
+
+    describe('multi character delimiters', () => {
+
+        test('simple paragraph', () => {
+
+            const paragraph = parseXml(`
+                <w:p>
+                    <w:r>
+                        <w:t>{{#loop}}{{/loop}}</w:t>
+                    </w:r>
+                </w:p>
+            `);
+
+            const textNode = xml.query.findByPath(paragraph, XmlNodeType.Text, 0, 0, 0);
+            const expected: DelimiterMark[] = [
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: true,
+                    index: 0,
+                    xmlTextNode: textNode
+                },
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: false,
+                    index: 7,
+                    xmlTextNode: textNode
+                },
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: true,
+                    index: 9,
+                    xmlTextNode: textNode
+                },
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: false,
+                    index: 16,
+                    xmlTextNode: textNode
+                }
+            ];
+
+            const searcher = createDelimiterSearcher({
+                tagStart: '{{',
+                tagEnd: '}}'
+            });
+            const delimiters = searcher.findDelimiters(paragraph);
+
+            expect(delimiters).toEqual(expected);
+        });
+
+        test('two different text nodes', () => {
+
+            const paragraph = parseXml(`
+                <w:p>
+                    <w:r>
+                        <w:t>{{#lo</w:t>
+                        <w:t>op}}</w:t>
+                    </w:r>
+                </w:p>
+            `);
+
+            const firstTextNode = xml.query.findByPath(paragraph, XmlNodeType.Text, 0, 0, 0);
+            const secondTextNode = xml.query.findByPath(paragraph, XmlNodeType.Text, 0, 1, 0);
+            const expected: DelimiterMark[] = [
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: true,
+                    index: 0,
+                    xmlTextNode: firstTextNode
+                },
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: false,
+                    index: 2,
+                    xmlTextNode: secondTextNode
+                }
+            ];
+
+            const searcher = createDelimiterSearcher({
+                tagStart: '{{',
+                tagEnd: '}}'
+            });
+            const delimiters = searcher.findDelimiters(paragraph);
+
+            expect(delimiters).toEqual(expected);
+        });
+
+        test('two different run nodes', () => {
+
+            const paragraph = parseXml(`
+                <w:p>
+                    <w:r>
+                        <w:t>{{</w:t>
+                    </w:r>
+                    <w:r>
+                        <w:t>tag</w:t>
+                    </w:r>
+                    <w:r>
+                        <w:t>}}</w:t>
+                    </w:r>
+                </w:p>
+            `);
+
+            const firstTextNode = xml.query.findByPath(paragraph, XmlNodeType.Text, 0, 0, 0);
+            const thirdTextNode = xml.query.findByPath(paragraph, XmlNodeType.Text, 2, 0, 0);
+            const expected: DelimiterMark[] = [
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: true,
+                    index: 0,
+                    xmlTextNode: firstTextNode
+                },
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: false,
+                    index: 0,
+                    xmlTextNode: thirdTextNode
+                }
+            ];
+
+            const searcher = createDelimiterSearcher({
+                tagStart: '{{',
+                tagEnd: '}}'
+            });
+            const delimiters = searcher.findDelimiters(paragraph);
+
+            expect(delimiters).toEqual(expected);
+        });
+
+        test('delimiters splitted across several different run nodes', () => {
+
+            const paragraph = parseXml(`
+                <w:p>
+                    <w:r>
+                        <w:t>{</w:t>
+                    </w:r>
+                    <w:r>
+                        <w:t>{{tag}</w:t>
+                    </w:r>
+                    <w:r>
+                        <w:t>}</w:t>
+                    </w:r>
+                    <w:r>
+                        <w:t>}</w:t>
+                    </w:r>
+                </w:p>
+            `);
+
+            const firstTextNode = xml.query.findByPath(paragraph, XmlNodeType.Text, 0, 0, 0);
+            const expected: DelimiterMark[] = [
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: true,
+                    index: 0,
+                    xmlTextNode: firstTextNode
+                },
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: false,
+                    index: 6,
+                    xmlTextNode: firstTextNode
+                }
+            ];
+
+            const searcher = createDelimiterSearcher({
+                tagStart: '{{{',
+                tagEnd: '}}}'
+            });
+            const delimiters = searcher.findDelimiters(paragraph);
+
+            expect(delimiters).toEqual(expected);
+        });
+
+        test('delimiters splitted across several different run nodes - with attribute tags of a floating drawing in the middle', () => {
+
+            const paragraph = parseXml(`
+                <w:p>
+                    <w:r>
+                        <w:t>{</w:t>
+                    </w:r>
+                    <w:r>
+                        <w:t>{{Text Tag}</w:t>
+                    </w:r>
+                    <w:r>
+                        <w:drawing>
+                            <wp:anchor>
+                                <wp:docPr descr="{{{Attribute Tag}}}"/>
+                            </wp:anchor>
+                        </w:drawing>
+                    </w:r>
+                    <w:r>
+                        <w:t>}</w:t>
+                    </w:r>
+                    <w:r>
+                        <w:t>}</w:t>
+                    </w:r>
+                </w:p>
+            `, false);
+
+            const firstTextNode = xml.query.findByPath(paragraph, XmlNodeType.Text, 0, 0, 0);
+            const imagePropertiesNode = xml.query.findByPath(paragraph, XmlNodeType.General, 2, 0, 0, 0);
+            const expected: DelimiterMark[] = [
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: true,
+                    index: 0,
+                    xmlTextNode: firstTextNode
+                },
+                {
+                    placement: TagPlacement.Attribute,
+                    isOpen: true,
+                    index: 0,
+                    xmlNode: imagePropertiesNode,
+                    attributeName: 'descr'
+                },
+                {
+                    placement: TagPlacement.Attribute,
+                    isOpen: false,
+                    index: 16,
+                    xmlNode: imagePropertiesNode,
+                    attributeName: 'descr'
+                },
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: false,
+                    index: 11,
+                    xmlTextNode: firstTextNode
+                }
+            ];
+
+            const searcher = createDelimiterSearcher({
+                tagStart: '{{{',
+                tagEnd: '}}}'
+            });
+            const delimiters = searcher.findDelimiters(paragraph);
+
+            expect(delimiters.length).toEqual(expected.length);
+            expect(delimiters).toEqual(expected);
+        });
+    });
+
+    describe('text contains multiple delimiter prefixes', () => {
+
+        test('simple paragraph', () => {
+
+            const paragraph = parseXml(`
+                <w:p>
+                    <w:r>
+                        <w:t>{{!#loop!}}{{!/loop!}}</w:t>
+                    </w:r>
+                </w:p>
+            `);
+
+            const textNode = xml.query.findByPath(paragraph, XmlNodeType.Text, 0, 0, 0);
+            const expected: DelimiterMark[] = [
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: true,
+                    index: 1,
+                    xmlTextNode: textNode
+                },
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: false,
+                    index: 8,
+                    xmlTextNode: textNode
+                },
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: true,
+                    index: 12,
+                    xmlTextNode: textNode
+                },
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: false,
+                    index: 19,
+                    xmlTextNode: textNode
+                }
+            ];
+
+            const searcher = createDelimiterSearcher({
+                tagStart: '{!',
+                tagEnd: '!}'
+            });
+            const delimiters = searcher.findDelimiters(paragraph);
+
+            expect(delimiters).toEqual(expected);
+        });
+
+        test('two different text nodes', () => {
+
+            const paragraph = parseXml(`
+                <w:p>
+                    <w:r>
+                        <w:t>{!#lo</w:t>
+                        <w:t>op!}</w:t>
+                    </w:r>
+                </w:p>
+            `);
+
+            const firstTextNode = xml.query.findByPath(paragraph, XmlNodeType.Text, 0, 0, 0);
+            const secondTextNode = xml.query.findByPath(paragraph, XmlNodeType.Text, 0, 1, 0);
+            const expected: DelimiterMark[] = [
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: true,
+                    index: 0,
+                    xmlTextNode: firstTextNode
+                },
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: false,
+                    index: 2,
+                    xmlTextNode: secondTextNode
+                }
+            ];
+
+            const searcher = createDelimiterSearcher({
+                tagStart: '{!',
+                tagEnd: '!}'
+            });
+            const delimiters = searcher.findDelimiters(paragraph);
+
+            expect(delimiters).toEqual(expected);
+        });
+
+        test('two different run nodes', () => {
+
+            const paragraph = parseXml(`
+                <w:p>
+                    <w:r>
+                        <w:t>{!</w:t>
+                    </w:r>
+                    <w:r>
+                        <w:t>tag</w:t>
+                    </w:r>
+                    <w:r>
+                        <w:t>!}</w:t>
+                    </w:r>
+                </w:p>
+            `);
+
+            const firstTextNode = xml.query.findByPath(paragraph, XmlNodeType.Text, 0, 0, 0);
+            const thirdTextNode = xml.query.findByPath(paragraph, XmlNodeType.Text, 2, 0, 0);
+            const expected: DelimiterMark[] = [
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: true,
+                    index: 0,
+                    xmlTextNode: firstTextNode
+                },
+                {
+                    placement: TagPlacement.TextNode,
+                    isOpen: false,
+                    index: 0,
+                    xmlTextNode: thirdTextNode
+                }
+            ];
+
+            const searcher = createDelimiterSearcher({
+                tagStart: '{!',
+                tagEnd: '!}'
+            });
+            const delimiters = searcher.findDelimiters(paragraph);
+
+            expect(delimiters).toEqual(expected);
+        });
+    });
+});
+
+function createDelimiterSearcher(delimitersSetup?: Partial<Delimiters>): DelimiterSearcher {
+    const delimiters = new Delimiters(delimitersSetup);
+    return new DelimiterSearcher(delimiters, 20);
+}