easy-template-x 6.2.2 → 7.0.0

package/src/office/officeMarkup.tests.ts

@@ -0,0 +1,114 @@
+import { officeMarkup, OfficeMarkup } from "src/office";
+import { XmlTextNode } from "src/xml";
+import { parseXml } from "test/testUtils";
+import { describe, expect, test } from "vitest";
+
+describe(OfficeMarkup, () => {
+
+    describe("modify", () => {
+
+        describe(officeMarkup.modify.joinTextNodesRange, () => {
+
+            test('join a range of text nodes from the same run', () => {
+                const paragraphNode = parseXml(`
+                    <w:p>
+                        <w:r>
+                            <w:t>1</w:t>
+                            <w:t>2</w:t>
+                            <w:t>3</w:t>
+                        </w:r>
+                    </w:p>
+                `);
+                const runNode = paragraphNode.childNodes[0];
+                const firstXmlTextNode = runNode.childNodes[0].childNodes[0] as XmlTextNode;
+                expect(firstXmlTextNode.textContent).toEqual('1');
+                const lastXmlTextNode = runNode.childNodes[2].childNodes[0] as XmlTextNode;
+                expect(lastXmlTextNode.textContent).toEqual('3');
+
+                officeMarkup.modify.joinTextNodesRange(firstXmlTextNode, lastXmlTextNode);
+
+                expect(runNode.childNodes.length).toEqual(1);
+                expect(runNode.childNodes[0].childNodes.length).toEqual(1);
+                expect(runNode.childNodes[0].childNodes[0]).toEqual(firstXmlTextNode);
+                expect(firstXmlTextNode.textContent).toEqual('123');
+            });
+
+            test('join a range of text nodes from three different runs', () => {
+                const paragraphNode = parseXml(`
+                    <w:p>
+                        <w:r>
+                            <w:t>1</w:t>
+                            <w:t>2</w:t>
+                            <w:t>3</w:t>
+                        </w:r>
+                        <w:r>
+                            <w:t>4</w:t>
+                        </w:r>
+                        <w:r>
+                            <w:t>5</w:t>
+                            <w:t>6</w:t>
+                        </w:r>
+                    </w:p>
+                `);
+                const firstRunNode = paragraphNode.childNodes[0];
+                const firstXmlTextNode = firstRunNode.childNodes[0].childNodes[0] as XmlTextNode;
+                expect(firstXmlTextNode.textContent).toEqual('1');
+                const thirdRunNode = paragraphNode.childNodes[2];
+                const lastXmlTextNode = thirdRunNode.childNodes[1].childNodes[0] as XmlTextNode;
+                expect(lastXmlTextNode.textContent).toEqual('6');
+
+                officeMarkup.modify.joinTextNodesRange(firstXmlTextNode, lastXmlTextNode);
+
+                expect(paragraphNode.childNodes.length).toEqual(1);
+                expect(firstRunNode.childNodes.length).toEqual(1);
+                expect(firstRunNode.childNodes[0].childNodes.length).toEqual(1);
+                expect(firstRunNode.childNodes[0].childNodes[0]).toEqual(firstXmlTextNode);
+                expect(firstXmlTextNode.textContent).toEqual('123456');
+            });
+
+            test('only join nodes from the specified range', () => {
+                const paragraphNode = parseXml(`
+                    <w:p>
+                        <w:r>
+                            <w:t>0</w:t>
+                        </w:r>
+                        <w:r>
+                            <w:t>1</w:t>
+                            <w:t>2</w:t>
+                            <w:t>3</w:t>
+                        </w:r>
+                        <w:r>
+                            <w:t>4</w:t>
+                        </w:r>
+                        <w:r>
+                            <w:t>5</w:t>
+                            <w:t>6</w:t>
+                        </w:r>
+                    </w:p>
+                `);
+
+                const fromRunNode = paragraphNode.childNodes[1];
+                const fromXmlTextNode = fromRunNode.childNodes[1].childNodes[0] as XmlTextNode;
+                expect(fromXmlTextNode.textContent).toEqual('2');
+
+                const toRunNode = paragraphNode.childNodes[2];
+                const toXmlTextNode = toRunNode.childNodes[0].childNodes[0] as XmlTextNode;
+                expect(toXmlTextNode.textContent).toEqual('4');
+
+                // modify
+
+                officeMarkup.modify.joinTextNodesRange(fromXmlTextNode, toXmlTextNode);
+
+                // assert
+
+                expect(paragraphNode.childNodes.length).toEqual(3);
+                expect(fromRunNode.childNodes.length).toEqual(2);
+                expect(fromRunNode.childNodes[1].childNodes.length).toEqual(1);
+                expect(fromRunNode.childNodes[1].childNodes[0]).toEqual(fromXmlTextNode);
+                expect(fromXmlTextNode.textContent).toEqual('234');
+            });
+
+        });
+    });
+
+});

package/src/office/officeMarkup.ts

@@ -1,4 +1,5 @@
-import { xml, XmlGeneralNode, XmlNode, XmlTextNode } from "src/xml";
+import { Tag, TagPlacement } from "src/compilation/tag";
+import { xml, XmlGeneralNode, XmlNode, XmlNodeType, XmlTextNode } from "src/xml";
 import { OmlAttribute, OmlNode } from "./omlNode";
 
 //
@@ -74,10 +75,14 @@ class Query {
 
     public isListParagraph(paragraphNode: XmlNode): boolean {
         const paragraphProperties = officeMarkup.query.findParagraphPropertiesNode(paragraphNode);
-        const listNumberProperties = xml.query.findChildByName(paragraphProperties, OmlNode.W.NumberProperties);
+        const listNumberProperties = xml.query.findByPath(paragraphProperties, XmlNodeType.General, OmlNode.W.NumberProperties);
         return !!listNumberProperties;
     }
 
+    public isInlineDrawingNode(node: XmlNode): boolean {
+        return node.nodeName === OmlNode.Wp.Inline && node.parentNode?.nodeName === OmlNode.W.Drawing;
+    }
+
     public findParagraphPropertiesNode(paragraphNode: XmlNode): XmlNode {
         if (!officeMarkup.query.isParagraphNode(paragraphNode))
             throw new Error(`Expected paragraph node but received a '${paragraphNode.nodeName}' node.`);
@@ -116,43 +121,43 @@ class Query {
             return null;
 
         if (!xml.query.isTextNode(node))
-            throw new Error(`'Invalid argument ${nameof(node)}. Expected a XmlTextNode.`);
+            throw new Error(`'Invalid argument node. Expected a XmlTextNode.`);
 
-        return xml.query.findParent(node, officeMarkup.query.isTextNode) as XmlGeneralNode;
+        return xml.query.findParent(node, officeMarkup.query.isTextNode);
     }
 
     /**
      * Search **upwards** for the first run node.
      */
-    public containingRunNode(node: XmlNode): XmlNode {
+    public containingRunNode(node: XmlNode): XmlGeneralNode {
         return xml.query.findParent(node, officeMarkup.query.isRunNode);
     }
 
     /**
      * Search **upwards** for the first paragraph node.
      */
-    public containingParagraphNode(node: XmlNode): XmlNode {
+    public containingParagraphNode(node: XmlNode): XmlGeneralNode {
         return xml.query.findParent(node, officeMarkup.query.isParagraphNode);
     }
 
     /**
      * Search **upwards** for the first "table row" node.
      */
-    public containingTableRowNode(node: XmlNode): XmlNode {
+    public containingTableRowNode(node: XmlNode): XmlGeneralNode {
         return xml.query.findParentByName(node, OmlNode.W.TableRow);
     }
 
     /**
      * Search **upwards** for the first "table cell" node.
      */
-    public containingTableCellNode(node: XmlNode): XmlNode {
+    public containingTableCellNode(node: XmlNode): XmlGeneralNode {
         return xml.query.findParent(node, officeMarkup.query.isTableCellNode);
     }
 
     /**
      * Search **upwards** for the first "table" node.
      */
-    public containingTableNode(node: XmlNode): XmlNode {
+    public containingTableNode(node: XmlNode): XmlGeneralNode {
         return xml.query.findParentByName(node, OmlNode.W.Table);
     }
 
@@ -262,7 +267,7 @@ class Modify {
         // input validation
         const containingParagraph = officeMarkup.query.containingParagraphNode(textNode);
         if (containingParagraph != paragraph)
-            throw new Error(`Node '${nameof(textNode)}' is not a descendant of '${nameof(paragraph)}'.`);
+            throw new Error(`Node 'textNode' is not a contained in the specified paragraph.`);
 
         const runNode = officeMarkup.query.containingRunNode(textNode);
         const wordTextNode = officeMarkup.query.containingTextNode(textNode);
@@ -342,7 +347,7 @@ class Modify {
         const totalText: string[] = [];
 
         // iterate runs
-        let curRunNode = firstRunNode;
+        let curRunNode: XmlNode = firstRunNode;
         while (curRunNode) {
 
             // iterate text nodes
@@ -424,18 +429,42 @@ class Modify {
         }
     }
 
-    public removeTag(textNode: XmlTextNode): void {
+    public removeTag(tag: Tag): void {
 
-        const wordTextNode = officeMarkup.query.containingTextNode(textNode);
-        const runNode = officeMarkup.query.containingRunNode(textNode);
+        if (tag.placement === TagPlacement.TextNode) {
+
+            const wordTextNode = officeMarkup.query.containingTextNode(tag.xmlTextNode);
+            const runNode = officeMarkup.query.containingRunNode(tag.xmlTextNode);
 
-        // Remove the word text node
-        xml.modify.remove(wordTextNode);
+            // Remove the word text node
+            xml.modify.remove(wordTextNode);
 
-        // Remove the run node if it's empty
-        if (officeMarkup.query.isEmptyRun(runNode)) {
-            xml.modify.remove(runNode);
+            // Remove the run node if it's empty
+            if (officeMarkup.query.isEmptyRun(runNode)) {
+                xml.modify.remove(runNode);
+            }
+
+            return;
         }
+
+        if (tag.placement === TagPlacement.Attribute) {
+            if (!tag.xmlNode.attributes || !(tag.attributeName in tag.xmlNode.attributes)) {
+                return;
+            }
+
+            // Remove the tag from the attribute value
+            tag.xmlNode.attributes[tag.attributeName] = tag.xmlNode.attributes[tag.attributeName].replace(tag.rawText, "");
+
+            // Remove the attribute if it's empty
+            if (tag.xmlNode.attributes[tag.attributeName] === "") {
+                delete tag.xmlNode.attributes[tag.attributeName];
+            }
+
+            return;
+        }
+
+        const anyTag = tag as any;
+        throw new Error(`Unexpected tag placement "${anyTag.placement}" for tag "${anyTag.rawText}".`);
     }
 }
 

package/src/office/omlNode.ts

@@ -11,11 +11,12 @@ class W {
     public readonly Table = 'w:tbl';
     public readonly TableRow = 'w:tr';
     public readonly TableCell = 'w:tc';
+    public readonly Drawing = 'w:drawing';
     public readonly NumberProperties = 'w:numPr';
 }
 
 /**
- * Drawing Markup Language node names.
+ * Drawing Markup Language main namespace node names.
  *
  * These elements are part of the main drawingML namespace:
  * xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main".
@@ -26,6 +27,68 @@ class A {
     public readonly Run = 'a:r';
     public readonly RunProperties = 'a:rPr';
     public readonly Text = 'a:t';
+    public readonly Graphic = 'a:graphic';
+    public readonly GraphicData = 'a:graphicData';
+    /**
+     * Binary large image (or) picture.
+     */
+    public readonly Blip = 'a:blip';
+    public readonly AlphaModFix = 'a:alphaModFix';
+}
+
+/**
+ * Drawing Markup Language "wordprocessing drawing" namespace node names.
+ * 
+ * These elements are part of the wordprocessingDrawing namespace:
+ * xmlns:wp="http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing".
+ */
+class Wp {
+    /**
+     * docPr stands for "Drawing Object Non-Visual Properties", which isn't
+     * exactly a good acronym but that's how it's called nevertheless.
+     */
+    public readonly DocPr = 'wp:docPr';
+    /**
+     * Inline DrawingML Object.
+     *
+     * see: http://officeopenxml.com/drwPicInline.php
+     */
+    public readonly Inline = 'wp:inline';
+    /**
+     * Anchor for Floating DrawingML Object.
+     * 
+     * see: http://officeopenxml.com/drwPicFloating.php
+     */
+    public readonly FloatingAnchor = 'wp:anchor';
+    /**
+     * Drawing extent.
+     */
+    public readonly Extent = 'wp:extent';
+}
+
+/**
+ * Drawing Markup Language "picture" namespace node names.
+ * 
+ * These elements are part of the picture namespace:
+ * xmlns:pic="http://schemas.openxmlformats.org/drawingml/2006/picture".
+ */
+class Pic {
+    public readonly Pic = 'pic:pic';
+    /**
+     * Non-visual picture properties.
+     */
+    public readonly NvPicPr = 'pic:nvPicPr';
+    public readonly CnVPr = 'pic:cNvPr';
+    /**
+     * Binary large image (or) picture fill.
+     */
+    public readonly BlipFill = 'pic:blipFill';
+    /**
+     * Shape properties.
+     */
+    public readonly SpPr = 'pic:spPr';
+    public readonly Xfrm = 'a:xfrm';
+    public readonly Ext = 'a:ext';
 }
 
 /**
@@ -44,9 +107,19 @@ export class OmlNode {
     public static readonly W = new W();
 
     /**
-     * Drawing Markup Language node names.
+     * Drawing Markup Language main namespace node names.
      */
     public static readonly A = new A();
+
+    /**
+     * Drawing Markup Language "wordprocessing drawing" namespace node names.
+     */
+    public static readonly Wp = new Wp();
+
+    /**
+     * Drawing Markup Language "picture" namespace node names.
+     */
+    public static readonly Pic = new Pic();
 }
 
 export class OmlAttribute {

package/src/office/openXmlPart.ts

@@ -50,7 +50,7 @@ export class OpenXmlPart {
     public async getText(): Promise<string> {
         const xmlDocument = await this.xmlRoot();
 
-        // ugly but good enough...
+        // Ugly but good enough...
         const xmlString = xml.parser.serializeFile(xmlDocument);
         const domDocument = xml.parser.domParse(xmlString);
 

package/src/office/rel.tests.ts

@@ -0,0 +1,23 @@
+import { MimeType } from "src/mimeType";
+import { RelsFile } from "src/office/relsFile";
+import { describe, expect, it } from "vitest";
+
+describe(RelsFile, () => {
+
+    describe(RelsFile.prototype.add, () => {
+
+        it('returns the same rel for the same target', async () => {
+
+            const fakeZip: any = {
+                getFile: (): any => null
+            };
+
+            const rels = new RelsFile('word/document.xml', fakeZip);
+
+            const rel1 = await rels.add('my image.jpeg', MimeType.Jpeg);
+            const rel2 = await rels.add('my image.jpeg', MimeType.Jpeg);
+
+            expect(rel1).toEqual(rel2);
+        });
+    });
+});

package/src/office/relationship.ts

@@ -23,22 +23,38 @@ export type RelTargetMode = 'Internal' | 'External';
 
 export class Relationship {
 
-    public static fromXml(xml: XmlGeneralNode): Relationship {
+    public static fromXml(partDir: string, xml: XmlGeneralNode): Relationship {
         return new Relationship({
             id: xml.attributes?.['Id'],
             type: xml.attributes?.['Type'],
-            target: Relationship.normalizeRelTarget(xml.attributes?.['Target']),
+            target: Relationship.normalizeRelTarget(partDir, xml.attributes?.['Target']),
             targetMode: xml.attributes?.['TargetMode'] as RelTargetMode,
         });
     }
 
-    public static normalizeRelTarget(target: string): string {
+    public static normalizeRelTarget(partDir: string, target: string): string {
         if (!target) {
             return target;
         }
+
+        // Remove leading slashes from input
+        if (partDir.startsWith('/')) {
+            partDir = partDir.substring(1);
+        }
+        if (target.startsWith('/')) {
+            target = target.substring(1);
+        }
+
+        // Convert target to relative path
+        if (target.startsWith(partDir)) {
+            target = target.substring(partDir.length);
+        }
+
+        // Remove leading slashes from output
         if (target.startsWith('/')) {
-            return target.substring(1);
+            target = target.substring(1);
         }
+
         return target;
     }
 
@@ -56,11 +72,11 @@ export class Relationship {
         const node = xml.create.generalNode('Relationship');
         node.attributes = {};
 
-        // set only non-empty attributes
+        // Set only non-empty attributes
         for (const propKey of Object.keys(this)) {
             const value = (this as any)[propKey];
             if (value && typeof value === 'string') {
-                const attrName = propKey[0].toUpperCase() + propKey.substr(1);
+                const attrName = propKey[0].toUpperCase() + propKey.substring(1);
                 node.attributes[attrName] = value;
             }
         }

package/src/office/relsFile.ts

@@ -31,21 +31,21 @@ export class RelsFile {
      */
     public async add(relTarget: string, relType: string, relTargetMode?: RelTargetMode): Promise<string> {
 
-        // if relTarget is an internal file it should be relative to the part dir
+        // If relTarget is an internal file it should be relative to the part dir
         if (this.partDir && relTarget.startsWith(this.partDir)) {
-            relTarget = relTarget.substr(this.partDir.length + 1);
+            relTarget = relTarget.substring(this.partDir.length + 1);
         }
 
-        // parse rels file
+        // Parse rels file
         await this.parseRelsFile();
 
-        // already exists?
+        // Already exists?
         const relTargetKey = this.getRelTargetKey(relType, relTarget);
         let relId = this.relTargets[relTargetKey];
         if (relId)
             return relId;
 
-        // create rel node
+        // Create rel node
         relId = this.getNextRelId();
         const rel = new Relationship({
             id: relId,
@@ -54,11 +54,11 @@ export class RelsFile {
             targetMode: relTargetMode
         });
 
-        // update lookups
+        // Update lookups
         this.rels[relId] = rel;
         this.relTargets[relTargetKey] = relId;
 
-        // return
+        // Return
         return relId;
     }
 
@@ -80,21 +80,21 @@ export class RelsFile {
      */
     public async save(): Promise<void> {
 
-        // not change - no need to save
+        // Not change - no need to save
         if (!this.rels)
             return;
 
-        // create rels xml
+        // Create rels xml
         const root = this.createRootNode();
         root.childNodes = Object.values(this.rels).map(rel => rel.toXml());
 
-        // serialize and save
+        // Serialize and save
         const xmlContent = xml.parser.serializeFile(root);
         this.zip.setFile(this.relsFilePath, xmlContent);
     }
 
     //
-    // private methods
+    // Private methods
     //
 
     private getNextRelId(): string {
@@ -110,11 +110,11 @@ export class RelsFile {
 
     private async parseRelsFile(): Promise<void> {
 
-        // already parsed
+        // Already parsed
         if (this.rels)
             return;
 
-        // parse xml
+        // Parse xml
         let root: XmlNode;
         const relsFile = this.zip.getFile(this.relsFilePath);
         if (relsFile) {
@@ -124,12 +124,13 @@ export class RelsFile {
             root = this.createRootNode();
         }
 
-        // parse relationship nodes
+        // Parse relationship nodes
         this.rels = {};
         this.relTargets = {};
         for (const relNode of root.childNodes) {
+            const genRelNode = relNode as XmlGeneralNode;
 
-            const attributes = (relNode as XmlGeneralNode).attributes;
+            const attributes = genRelNode.attributes;
             if (!attributes)
                 continue;
 
@@ -137,15 +138,13 @@ export class RelsFile {
             if (!idAttr)
                 continue;
 
-            // store rel
-            const rel = Relationship.fromXml(relNode as XmlGeneralNode);
+            // Store rel
+            const rel = Relationship.fromXml(this.partDir, genRelNode);
             this.rels[idAttr] = rel;
 
-            // create rel target lookup
-            const typeAttr = attributes['Type'];
-            const targetAttr = Relationship.normalizeRelTarget(attributes['Target']);
-            if (typeAttr && targetAttr) {
-                const relTargetKey = this.getRelTargetKey(typeAttr, targetAttr);
+            // Create rel target lookup
+            if (rel.type && rel.target) {
+                const relTargetKey = this.getRelTargetKey(rel.type, rel.target);
                 this.relTargets[relTargetKey] = idAttr;
             }
         }

package/src/office/xlsx.ts

@@ -21,7 +21,7 @@ export class Xlsx {
         try {
             zip = await Zip.load(file);
         } catch {
-            throw new MalformedFileError('xlsx');
+            throw new MalformedFileError("Failed to load zip file.");
         }
 
         // Load the xlsx file
@@ -35,7 +35,7 @@ export class Xlsx {
     public static async open(zip: Zip): Promise<Xlsx> {
         const mainDocumentPath = await Xlsx.getMainDocumentPath(zip);
         if (!mainDocumentPath)
-            throw new MalformedFileError('xlsx');
+            throw new MalformedFileError("Cannot find main document path.");
 
         return new Xlsx(mainDocumentPath, zip);
     }