@ansonlai/docx-redline-js 0.1.0

package/services/comment-locator.js

@@ -0,0 +1,197 @@
+/**
+ * Comment text location and marker injection helpers.
+ */
+
+import { NS_W } from '../core/types.js';
+import { getElementsByTag, getFirstElementByTag } from '../core/xml-query.js';
+
+/**
+ * Builds a paragraph text index in a single pass for repeated lookups.
+ *
+ * @param {Element} paragraph - w:p element
+ * @returns {{ fullText: string, runOffsets: Array<{run: Element, start: number, end: number}> }}
+ */
+export function createParagraphTextIndex(paragraph) {
+    const runs = getElementsByTag(paragraph, 'w:r');
+    const runOffsets = [];
+    let fullText = '';
+
+    for (const run of runs) {
+        const start = fullText.length;
+        const textNodes = getElementsByTag(run, 'w:t');
+        for (const textNode of textNodes) {
+            fullText += textNode.textContent || '';
+        }
+        runOffsets.push({ run, start, end: fullText.length });
+    }
+
+    return { fullText, runOffsets };
+}
+
+/**
+ * Finds text within a prebuilt paragraph text index.
+ *
+ * @param {{ fullText: string, runOffsets: Array<{run: Element, start: number, end: number}> }} paragraphIndex - Prebuilt index
+ * @param {string} searchText - Text to locate
+ * @returns {{ found: boolean, startRun?: Element, startOffset?: number, endRun?: Element, endOffset?: number }}
+ */
+export function findTextInParagraphIndex(paragraphIndex, searchText) {
+    const searchIndex = paragraphIndex.fullText.indexOf(searchText);
+    if (searchIndex === -1) {
+        return { found: false };
+    }
+
+    const searchEnd = searchIndex + searchText.length;
+    let startRun = null;
+    let endRun = null;
+    let startOffset = 0;
+    let endOffset = 0;
+
+    for (const { run, start, end } of paragraphIndex.runOffsets) {
+        if (searchIndex >= start && searchIndex < end) {
+            startRun = run;
+            startOffset = searchIndex - start;
+        }
+        if (searchEnd > start && searchEnd <= end) {
+            endRun = run;
+            endOffset = searchEnd - start;
+        }
+    }
+
+    return {
+        found: true,
+        startRun,
+        startOffset,
+        endRun,
+        endOffset
+    };
+}
+
+function cloneRunWithText(xmlDoc, rPr, newText) {
+    const newRun = xmlDoc.createElementNS(NS_W, 'w:r');
+    if (rPr) {
+        newRun.appendChild(rPr.cloneNode(true));
+    }
+
+    const newTextNode = xmlDoc.createElementNS(NS_W, 'w:t');
+    newTextNode.setAttribute('xml:space', 'preserve');
+    newTextNode.textContent = newText;
+    newRun.appendChild(newTextNode);
+    return newRun;
+}
+
+/**
+ * Injects comment markers around text in a paragraph.
+ *
+ * @param {Document} xmlDoc - XML document
+ * @param {Element} paragraph - w:p element
+ * @param {string} textToFind - Target text
+ * @param {number} commentId - Comment id
+ * @param {{ fullText: string, runOffsets: Array<{run: Element, start: number, end: number}> }|null} [paragraphIndex=null] - Optional prebuilt index
+ * @returns {boolean}
+ */
+export function injectMarkersIntoParagraph(xmlDoc, paragraph, textToFind, commentId, paragraphIndex = null) {
+    const activeIndex = paragraphIndex || createParagraphTextIndex(paragraph);
+    const location = findTextInParagraphIndex(activeIndex, textToFind);
+    if (!location.found || !location.startRun) {
+        return false;
+    }
+
+    const startMarker = xmlDoc.createElementNS(NS_W, 'w:commentRangeStart');
+    startMarker.setAttribute('w:id', String(commentId));
+
+    const endMarker = xmlDoc.createElementNS(NS_W, 'w:commentRangeEnd');
+    endMarker.setAttribute('w:id', String(commentId));
+
+    const referenceRun = xmlDoc.createElementNS(NS_W, 'w:r');
+    const reference = xmlDoc.createElementNS(NS_W, 'w:commentReference');
+    reference.setAttribute('w:id', String(commentId));
+    referenceRun.appendChild(reference);
+
+    if (location.startRun === location.endRun) {
+        const run = location.startRun;
+        const textNode = getFirstElementByTag(run, 'w:t');
+        if (!textNode) {
+            run.parentNode.insertBefore(startMarker, run);
+            if (run.nextSibling) {
+                run.parentNode.insertBefore(endMarker, run.nextSibling);
+                endMarker.parentNode.insertBefore(referenceRun, endMarker.nextSibling);
+            } else {
+                run.parentNode.appendChild(endMarker);
+                run.parentNode.appendChild(referenceRun);
+            }
+            return true;
+        }
+
+        const fullText = textNode.textContent || '';
+        const beforeText = fullText.substring(0, location.startOffset);
+        const highlightedText = fullText.substring(location.startOffset, location.endOffset);
+        const afterText = fullText.substring(location.endOffset);
+        const rPr = getFirstElementByTag(run, 'w:rPr');
+        const parent = run.parentNode;
+
+        if (beforeText) {
+            parent.insertBefore(cloneRunWithText(xmlDoc, rPr, beforeText), run);
+        }
+
+        parent.insertBefore(startMarker, run);
+        textNode.textContent = highlightedText;
+
+        if (run.nextSibling) {
+            parent.insertBefore(endMarker, run.nextSibling);
+        } else {
+            parent.appendChild(endMarker);
+        }
+        parent.insertBefore(referenceRun, endMarker.nextSibling || null);
+
+        if (afterText) {
+            parent.insertBefore(cloneRunWithText(xmlDoc, rPr, afterText), referenceRun.nextSibling || null);
+        }
+
+        return true;
+    }
+
+    const startTextNode = getFirstElementByTag(location.startRun, 'w:t');
+    if (startTextNode && location.startOffset > 0) {
+        const fullText = startTextNode.textContent || '';
+        const beforeText = fullText.substring(0, location.startOffset);
+        const highlightedStart = fullText.substring(location.startOffset);
+
+        if (beforeText) {
+            const rPr = getFirstElementByTag(location.startRun, 'w:rPr');
+            location.startRun.parentNode.insertBefore(cloneRunWithText(xmlDoc, rPr, beforeText), location.startRun);
+        }
+        startTextNode.textContent = highlightedStart;
+    }
+
+    location.startRun.parentNode.insertBefore(startMarker, location.startRun);
+
+    const endRun = location.endRun || location.startRun;
+    const endTextNode = getFirstElementByTag(endRun, 'w:t');
+    if (endTextNode && location.endOffset < (endTextNode.textContent || '').length) {
+        const fullText = endTextNode.textContent || '';
+        const highlightedEnd = fullText.substring(0, location.endOffset);
+        const afterText = fullText.substring(location.endOffset);
+
+        endTextNode.textContent = highlightedEnd;
+
+        if (afterText) {
+            const rPr = getFirstElementByTag(endRun, 'w:rPr');
+            if (endRun.nextSibling) {
+                endRun.parentNode.insertBefore(cloneRunWithText(xmlDoc, rPr, afterText), endRun.nextSibling);
+            } else {
+                endRun.parentNode.appendChild(cloneRunWithText(xmlDoc, rPr, afterText));
+            }
+        }
+    }
+
+    if (endRun.nextSibling) {
+        endRun.parentNode.insertBefore(endMarker, endRun.nextSibling);
+        endMarker.parentNode.insertBefore(referenceRun, endMarker.nextSibling);
+    } else {
+        endRun.parentNode.appendChild(endMarker);
+        endRun.parentNode.appendChild(referenceRun);
+    }
+
+    return true;
+}

package/services/comment-package.js

@@ -0,0 +1,113 @@
+/**
+ * Comment package builders and pkg:part wiring.
+ */
+
+import { createParser, createSerializer } from '../adapters/xml-adapter.js';
+import { error as logError } from '../adapters/logger.js';
+import { buildDocumentCommentsPackage, buildParagraphCommentsPackage } from './package-builder.js';
+import { getElementsByTagNS, getXmlParseError } from '../core/xml-query.js';
+
+const PKG_NS = 'http://schemas.microsoft.com/office/2006/xmlPackage';
+const RELS_NS = 'http://schemas.openxmlformats.org/package/2006/relationships';
+
+/**
+ * Wraps paragraph XML with minimal package structure including comments part.
+ *
+ * @param {string} paragraphXml - Paragraph XML content
+ * @param {string} commentsXml - comments.xml payload
+ * @returns {string}
+ */
+export function wrapParagraphWithComments(paragraphXml, commentsXml) {
+    return buildParagraphCommentsPackage(paragraphXml, commentsXml);
+}
+
+/**
+ * Injects comments.xml and relationship entry into an existing pkg:package.
+ *
+ * @param {string} packageOxml - Existing package XML
+ * @param {string} commentsXml - comments.xml payload
+ * @returns {string}
+ */
+export function injectCommentsIntoPackage(packageOxml, commentsXml) {
+    const parser = createParser();
+    const serializer = createSerializer();
+    const pkgDoc = parser.parseFromString(packageOxml, 'text/xml');
+
+    const parseError = getXmlParseError(pkgDoc);
+    if (parseError) {
+        logError('[CommentEngine] Failed to parse package:', parseError.textContent);
+        return packageOxml;
+    }
+
+    const pkgPackage = pkgDoc.documentElement;
+
+    const commentsPart = pkgDoc.createElementNS(PKG_NS, 'pkg:part');
+    commentsPart.setAttribute('pkg:name', '/word/comments.xml');
+    commentsPart.setAttribute('pkg:contentType', 'application/vnd.openxmlformats-officedocument.wordprocessingml.comments+xml');
+
+    const commentsXmlData = pkgDoc.createElementNS(PKG_NS, 'pkg:xmlData');
+    const commentsDoc = parser.parseFromString(commentsXml, 'text/xml');
+    commentsXmlData.appendChild(pkgDoc.importNode(commentsDoc.documentElement, true));
+    commentsPart.appendChild(commentsXmlData);
+    pkgPackage.appendChild(commentsPart);
+
+    const parts = getElementsByTagNS(pkgPackage, PKG_NS, 'part');
+    const docRelsPart = parts.find(part => part.getAttribute('pkg:name') === '/word/_rels/document.xml.rels');
+
+    if (docRelsPart) {
+        const xmlDataNodes = getElementsByTagNS(docRelsPart, PKG_NS, 'xmlData');
+        if (xmlDataNodes.length > 0) {
+            const relsNodes = getElementsByTagNS(xmlDataNodes[0], RELS_NS, 'Relationships');
+            if (relsNodes.length > 0) {
+                const relationships = relsNodes[0];
+                const existingRels = getElementsByTagNS(relationships, RELS_NS, 'Relationship');
+                const hasCommentsRel = existingRels.some(rel =>
+                    rel.getAttribute('Type')?.includes('comments')
+                );
+
+                if (!hasCommentsRel) {
+                    let maxId = 0;
+                    existingRels.forEach(rel => {
+                        const id = rel.getAttribute('Id');
+                        const idNumber = parseInt(id?.replace('rId', '') || '0', 10);
+                        if (idNumber > maxId) maxId = idNumber;
+                    });
+
+                    const newRel = pkgDoc.createElementNS(RELS_NS, 'Relationship');
+                    newRel.setAttribute('Id', `rId${maxId + 1}`);
+                    newRel.setAttribute('Type', 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments');
+                    newRel.setAttribute('Target', 'comments.xml');
+                    relationships.appendChild(newRel);
+                }
+            }
+        }
+    } else {
+        const newDocRelsPart = pkgDoc.createElementNS(PKG_NS, 'pkg:part');
+        newDocRelsPart.setAttribute('pkg:name', '/word/_rels/document.xml.rels');
+        newDocRelsPart.setAttribute('pkg:contentType', 'application/vnd.openxmlformats-package.relationships+xml');
+
+        const relsXmlData = pkgDoc.createElementNS(PKG_NS, 'pkg:xmlData');
+        const relationships = pkgDoc.createElementNS(RELS_NS, 'Relationships');
+        const commentsRel = pkgDoc.createElementNS(RELS_NS, 'Relationship');
+        commentsRel.setAttribute('Id', 'rId1');
+        commentsRel.setAttribute('Type', 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments');
+        commentsRel.setAttribute('Target', 'comments.xml');
+        relationships.appendChild(commentsRel);
+        relsXmlData.appendChild(relationships);
+        newDocRelsPart.appendChild(relsXmlData);
+        pkgPackage.appendChild(newDocRelsPart);
+    }
+
+    return serializer.serializeToString(pkgDoc);
+}
+
+/**
+ * @deprecated Use injectCommentsIntoPackage instead.
+ *
+ * @param {string} documentXml - Document OOXML
+ * @param {string} commentsXml - comments.xml payload
+ * @returns {string}
+ */
+export function wrapWithCommentsPart(documentXml, commentsXml) {
+    return buildDocumentCommentsPackage(documentXml, commentsXml);
+}