docxmlater 10.1.4 → 10.1.6

package/dist/elements/Hyperlink.js

@@ -19,6 +19,7 @@ class Hyperlink {
     docLocation;
     trackingContext;
     _parentParagraph;
+    _preTrackingFormatting;
     constructor(properties) {
         this.url = properties.url;
         this.anchor = properties.anchor;
@@ -34,14 +35,14 @@ class Hyperlink {
                 `Use Hyperlink.createExternal() or Hyperlink.createInternal() to avoid ambiguity.`);
         }
         if (this._isEmpty) {
-            this.text = "";
+            this.text = '';
             this.formatting = {};
-            this.run = new Run_1.Run("", {});
+            this.run = new Run_1.Run('', {});
             return;
         }
-        this.text = properties.text || this.url || "Link";
+        this.text = properties.text || this.url || 'Link';
         const validation = (0, validation_1.validateRunText)(this.text, {
-            context: "Hyperlink text",
+            context: 'Hyperlink text',
             autoClean: properties.formatting?.cleanXmlFromText !== false,
             warnToConsole: true,
         });
@@ -49,10 +50,10 @@ class Hyperlink {
             this.text = validation.cleanedText;
         }
         this.formatting = {
-            font: "Verdana",
+            font: 'Verdana',
             size: 12,
-            color: "0000FF",
-            underline: "single",
+            color: '0000FF',
+            underline: 'single',
             ...properties.formatting,
         };
         this.run = new Run_1.Run(this.text, this.formatting);
@@ -66,6 +67,37 @@ class Hyperlink {
     _getParentParagraph() {
         return this._parentParagraph;
     }
+    _applyFormattingRPrChange(previousFormatting) {
+        if (!this._preTrackingFormatting) {
+            this._preTrackingFormatting = { ...previousFormatting };
+        }
+        const baseline = this._preTrackingFormatting;
+        const current = this.formatting;
+        const previousProperties = {};
+        let hasChanges = false;
+        for (const key of Object.keys(baseline)) {
+            if (baseline[key] !== current[key]) {
+                previousProperties[key] = baseline[key];
+                hasChanges = true;
+            }
+        }
+        for (const key of Object.keys(current)) {
+            if (!(key in baseline) && current[key] !== undefined) {
+                previousProperties[key] = undefined;
+                hasChanges = true;
+            }
+        }
+        if (!hasChanges)
+            return;
+        const revisionId = this.trackingContext.getRevisionManager().consumeNextId();
+        const author = this.trackingContext.getAuthor();
+        this.run.setPropertyChangeRevision({
+            id: revisionId,
+            author,
+            date: new Date(),
+            previousProperties,
+        });
+    }
     getUrl() {
         return this.url;
     }
@@ -107,17 +139,29 @@ class Hyperlink {
     }
     setText(text) {
         const validation = (0, validation_1.validateRunText)(text, {
-            context: "Hyperlink.setText",
+            context: 'Hyperlink.setText',
             autoClean: this.formatting.cleanXmlFromText !== false,
             warnToConsole: true,
         });
         const cleanedText = validation.cleanedText || text;
         const previousValue = this.text;
+        if (previousValue === cleanedText) {
+            return this;
+        }
+        if (this.trackingContext?.isEnabled() && this._parentParagraph) {
+            const author = this.trackingContext.getAuthor();
+            const oldHyperlink = this.clone();
+            this.text = cleanedText;
+            this.run.setText(cleanedText);
+            const deletion = Revision_1.Revision.createDeletion(author, [oldHyperlink]);
+            const insertion = Revision_1.Revision.createInsertion(author, [this]);
+            this._parentParagraph.replaceContent(this, [deletion, insertion]);
+            this._parentParagraph = undefined;
+            this._preTrackingFormatting = undefined;
+            return this;
+        }
         this.text = cleanedText;
         this.run.setText(cleanedText);
-        if (this.trackingContext?.isEnabled() && previousValue !== cleanedText) {
-            this.trackingContext.trackHyperlinkChange(this, 'text', previousValue, cleanedText);
-        }
         return this;
     }
     setRun(run) {
@@ -130,10 +174,21 @@ class Hyperlink {
     }
     setTooltip(tooltip) {
         const previousValue = this.tooltip;
-        this.tooltip = tooltip;
-        if (this.trackingContext?.isEnabled() && previousValue !== tooltip) {
-            this.trackingContext.trackHyperlinkChange(this, 'tooltip', previousValue, tooltip);
+        if (previousValue === tooltip) {
+            return this;
+        }
+        if (this.trackingContext?.isEnabled() && this._parentParagraph) {
+            const author = this.trackingContext.getAuthor();
+            const oldHyperlink = this.clone();
+            this.tooltip = tooltip;
+            const deletion = Revision_1.Revision.createDeletion(author, [oldHyperlink]);
+            const insertion = Revision_1.Revision.createInsertion(author, [this]);
+            this._parentParagraph.replaceContent(this, [deletion, insertion]);
+            this._parentParagraph = undefined;
+            this._preTrackingFormatting = undefined;
+            return this;
         }
+        this.tooltip = tooltip;
         return this;
     }
     getRelationshipId() {
@@ -159,7 +214,7 @@ class Hyperlink {
             this.url = url;
             this.relationshipId = undefined;
             if (this.run.getText() === oldUrl) {
-                this.text = url || this.anchor || "Link";
+                this.text = url || this.anchor || 'Link';
                 this.run.setText(this.text);
             }
             const deletion = Revision_1.Revision.createDeletion(author, [oldHyperlink]);
@@ -171,7 +226,7 @@ class Hyperlink {
         this.url = url;
         this.relationshipId = undefined;
         if (this.run.getText() === oldUrl) {
-            this.text = url || this.anchor || "Link";
+            this.text = url || this.anchor || 'Link';
             this.run.setText(this.text);
         }
         return this;
@@ -197,7 +252,7 @@ class Hyperlink {
                 this.relationshipId = undefined;
             }
             if (this.run.getText() === oldAnchor) {
-                this.text = anchor || this.url || "Link";
+                this.text = anchor || this.url || 'Link';
                 this.run.setText(this.text);
             }
             const deletion = Revision_1.Revision.createDeletion(author, [oldHyperlink]);
@@ -214,7 +269,7 @@ class Hyperlink {
             this.relationshipId = undefined;
         }
         if (this.run.getText() === oldAnchor) {
-            this.text = anchor || this.url || "Link";
+            this.text = anchor || this.url || 'Link';
             this.run.setText(this.text);
         }
         return this;
@@ -223,7 +278,7 @@ class Hyperlink {
         return this.run;
     }
     setFormatting(formatting, options) {
-        const previousValue = { ...this.formatting };
+        const previousFormatting = { ...this.formatting };
         if (options?.replace) {
             this.formatting = { ...formatting };
         }
@@ -234,7 +289,7 @@ class Hyperlink {
         this.run = new Run_1.Run(currentText, this.formatting);
         this.text = currentText;
         if (this.trackingContext?.isEnabled()) {
-            this.trackingContext.trackHyperlinkChange(this, 'formatting', previousValue, this.formatting);
+            this._applyFormattingRPrChange(previousFormatting);
         }
         return this;
     }
@@ -263,56 +318,56 @@ class Hyperlink {
         return this.formatting.size;
     }
     setColor(color) {
-        const previousValue = this.formatting.color;
+        const previousFormatting = { ...this.formatting };
         this.formatting.color = color;
         this.run = new Run_1.Run(this.text, this.formatting);
-        if (this.trackingContext?.isEnabled() && previousValue !== color) {
-            this.trackingContext.trackHyperlinkChange(this, 'color', previousValue, color);
+        if (this.trackingContext?.isEnabled() && previousFormatting.color !== color) {
+            this._applyFormattingRPrChange(previousFormatting);
         }
         return this;
     }
     setUnderline(underline) {
-        const previousValue = this.formatting.underline;
+        const previousFormatting = { ...this.formatting };
         this.formatting.underline = underline;
         this.run = new Run_1.Run(this.text, this.formatting);
-        if (this.trackingContext?.isEnabled() && previousValue !== underline) {
-            this.trackingContext.trackHyperlinkChange(this, 'underline', previousValue, underline);
+        if (this.trackingContext?.isEnabled() && previousFormatting.underline !== underline) {
+            this._applyFormattingRPrChange(previousFormatting);
         }
         return this;
     }
     setBold(bold = true) {
-        const previousValue = this.formatting.bold;
+        const previousFormatting = { ...this.formatting };
         this.formatting.bold = bold;
         this.run = new Run_1.Run(this.text, this.formatting);
-        if (this.trackingContext?.isEnabled() && previousValue !== bold) {
-            this.trackingContext.trackHyperlinkChange(this, 'bold', previousValue, bold);
+        if (this.trackingContext?.isEnabled() && previousFormatting.bold !== bold) {
+            this._applyFormattingRPrChange(previousFormatting);
         }
         return this;
     }
     setItalic(italic = true) {
-        const previousValue = this.formatting.italic;
+        const previousFormatting = { ...this.formatting };
         this.formatting.italic = italic;
         this.run = new Run_1.Run(this.text, this.formatting);
-        if (this.trackingContext?.isEnabled() && previousValue !== italic) {
-            this.trackingContext.trackHyperlinkChange(this, 'italic', previousValue, italic);
+        if (this.trackingContext?.isEnabled() && previousFormatting.italic !== italic) {
+            this._applyFormattingRPrChange(previousFormatting);
         }
         return this;
     }
     setFont(font) {
-        const previousValue = this.formatting.font;
+        const previousFormatting = { ...this.formatting };
         this.formatting.font = font;
         this.run = new Run_1.Run(this.text, this.formatting);
-        if (this.trackingContext?.isEnabled() && previousValue !== font) {
-            this.trackingContext.trackHyperlinkChange(this, 'font', previousValue, font);
+        if (this.trackingContext?.isEnabled() && previousFormatting.font !== font) {
+            this._applyFormattingRPrChange(previousFormatting);
         }
         return this;
     }
     setSize(size) {
-        const previousValue = this.formatting.size;
+        const previousFormatting = { ...this.formatting };
         this.formatting.size = size;
         this.run = new Run_1.Run(this.text, this.formatting);
-        if (this.trackingContext?.isEnabled() && previousValue !== size) {
-            this.trackingContext.trackHyperlinkChange(this, 'size', previousValue, size);
+        if (this.trackingContext?.isEnabled() && previousFormatting.size !== size) {
+            this._applyFormattingRPrChange(previousFormatting);
         }
         return this;
     }
@@ -337,77 +392,76 @@ class Hyperlink {
             };
         }
         if (!this.url) {
-            issues.push("No URL or anchor specified");
+            issues.push('No URL or anchor specified');
             return { valid: false, issues, fixed, originalUrl };
         }
         if (fixCommonIssues && fixedUrl) {
-            if (!(/^[a-z]+:\/\//i.exec(fixedUrl))) {
-                fixedUrl = "https://" + fixedUrl;
-                fixed.push("Added missing protocol (https://)");
+            if (!/^[a-z]+:\/\//i.exec(fixedUrl)) {
+                fixedUrl = 'https://' + fixedUrl;
+                fixed.push('Added missing protocol (https://)');
             }
             const protocolMatch = /^([a-z]+:\/\/)/i.exec(fixedUrl);
             if (protocolMatch?.[1]) {
                 const protocol = protocolMatch[1];
                 const rest = fixedUrl.substring(protocol.length);
-                const fixedRest = rest.replace(/\/\//g, "/");
+                const fixedRest = rest.replace(/\/\//g, '/');
                 if (rest !== fixedRest) {
                     fixedUrl = protocol + fixedRest;
-                    fixed.push("Fixed double slashes");
+                    fixed.push('Fixed double slashes');
                 }
             }
-            if (fixedUrl.includes(" ")) {
-                fixedUrl = fixedUrl.replace(/ /g, "%20");
-                fixed.push("Encoded spaces as %20");
+            if (fixedUrl.includes(' ')) {
+                fixedUrl = fixedUrl.replace(/ /g, '%20');
+                fixed.push('Encoded spaces as %20');
             }
             if (/^https?:\/\/[^/]+\/.+\/$/.exec(fixedUrl)) {
-                fixedUrl = fixedUrl.replace(/\/$/, "");
-                fixed.push("Removed trailing slash");
+                fixedUrl = fixedUrl.replace(/\/$/, '');
+                fixed.push('Removed trailing slash');
             }
-            fixedUrl = fixedUrl.replace(/^http:\/\//i, "https://");
-            if (fixedUrl !== this.url && fixedUrl.startsWith("https://")) {
-                fixed.push("Upgraded HTTP to HTTPS");
+            fixedUrl = fixedUrl.replace(/^http:\/\//i, 'https://');
+            if (fixedUrl !== this.url && fixedUrl.startsWith('https://')) {
+                fixed.push('Upgraded HTTP to HTTPS');
             }
             if (fixedUrl !== this.url) {
                 this.setUrl(fixedUrl);
             }
         }
         if (checkAccessibility && fixedUrl?.match(/^https?:\/\//i)) {
-            if (typeof fetch === "undefined") {
-                issues.push("Network validation unavailable: fetch API not supported in this environment");
+            if (typeof fetch === 'undefined') {
+                issues.push('Network validation unavailable: fetch API not supported in this environment');
             }
             else {
                 try {
                     const controller = new AbortController();
                     const timeoutId = setTimeout(() => controller.abort(), timeout);
                     const response = await fetch(fixedUrl, {
-                        method: "HEAD",
+                        method: 'HEAD',
                         signal: controller.signal,
-                        redirect: "follow",
+                        redirect: 'follow',
                     });
                     clearTimeout(timeoutId);
                     if (!response.ok) {
-                        issues.push(`HTTP ${response.status}: ${response.statusText || "Error"}`);
+                        issues.push(`HTTP ${response.status}: ${response.statusText || 'Error'}`);
                     }
                 }
                 catch (error) {
                     const isErrorWithName = (err) => {
-                        return typeof err === "object" && err !== null && "name" in err;
+                        return typeof err === 'object' && err !== null && 'name' in err;
                     };
                     const isErrorWithMessage = (err) => {
-                        return typeof err === "object" && err !== null && "message" in err;
+                        return typeof err === 'object' && err !== null && 'message' in err;
                     };
-                    if (isErrorWithName(error) && error.name === "AbortError") {
+                    if (isErrorWithName(error) && error.name === 'AbortError') {
                         issues.push(`Timeout after ${timeout}ms`);
                     }
-                    else if (isErrorWithMessage(error) &&
-                        error.message?.includes("fetch")) {
+                    else if (isErrorWithMessage(error) && error.message?.includes('fetch')) {
                         issues.push(`Unreachable: ${error.message}`);
                     }
                     else if (isErrorWithMessage(error)) {
                         issues.push(`Network error: ${error.message}`);
                     }
                     else {
-                        issues.push("Network error: Unknown error");
+                        issues.push('Network error: Unknown error');
                     }
                 }
             }
@@ -422,9 +476,9 @@ class Hyperlink {
     }
     resetToStandardFormatting() {
         const standardFormatting = {
-            font: "Verdana",
-            color: "0000FF",
-            underline: "single",
+            font: 'Verdana',
+            color: '0000FF',
+            underline: 'single',
             bold: false,
             italic: false,
             strike: false,
@@ -452,13 +506,17 @@ class Hyperlink {
         });
         if (this.run) {
             cloned.run = new Run_1.Run(this.run.getText(), { ...this.run.getFormatting() });
+            const existingRPrChange = this.run.getPropertyChangeRevision();
+            if (existingRPrChange) {
+                cloned.run.setPropertyChangeRevision({ ...existingRPrChange });
+            }
         }
         return cloned;
     }
     toXML() {
         if (!this.url && !this.anchor && !this.relationshipId) {
-            throw new Error("CRITICAL: Hyperlink must have either a URL (external link), anchor (internal link), or relationshipId. " +
-                "Cannot generate valid XML for hyperlink without destination.");
+            throw new Error('CRITICAL: Hyperlink must have either a URL (external link), anchor (internal link), or relationshipId. ' +
+                'Cannot generate valid XML for hyperlink without destination.');
         }
         if (this.url && !this.relationshipId) {
             throw new Error(`CRITICAL: External hyperlink to "${this.url}" is missing relationship ID. ` +
@@ -468,33 +526,33 @@ class Hyperlink {
         }
         const attributes = {};
         if (this.relationshipId) {
-            attributes["r:id"] = this.relationshipId;
+            attributes['r:id'] = this.relationshipId;
         }
         if (this.anchor) {
-            attributes["w:anchor"] = this.anchor;
+            attributes['w:anchor'] = this.anchor;
         }
         if (this.tooltip) {
-            attributes["w:tooltip"] = this.tooltip;
+            attributes['w:tooltip'] = this.tooltip;
         }
         if (this.tgtFrame) {
-            attributes["w:tgtFrame"] = this.tgtFrame;
+            attributes['w:tgtFrame'] = this.tgtFrame;
         }
         if (this.history) {
-            attributes["w:history"] = this.history;
+            attributes['w:history'] = this.history;
         }
         if (this.docLocation) {
-            attributes["w:docLocation"] = this.docLocation;
+            attributes['w:docLocation'] = this.docLocation;
         }
         if (this._isEmpty) {
             return {
-                name: "w:hyperlink",
+                name: 'w:hyperlink',
                 attributes,
                 children: [],
             };
         }
         const runXml = this.run.toXML();
         return {
-            name: "w:hyperlink",
+            name: 'w:hyperlink',
             attributes,
             children: [runXml],
         };