@ansonlai/docx-redline-js 0.9.0 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ansonlai/docx-redline-js",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "description": "Host-independent OOXML reconciliation engine for .docx manipulation with track changes",
   "license": "MIT",
   "type": "module",

package/pipeline/content-analysis.js

@@ -22,7 +22,8 @@ export function parseTable(text) {
 
     const isSeparatorLine = line => {
         const normalized = line.replace(/\s+/g, '');
-        return /^\|:?-{3,}:?(\|:?-{3,}:?)+\|?$/.test(normalized);
+        // One column needs a pipe on both sides ("|---|"), so a bare "---" or "|---" is not a separator.
+        return /^\|:?-{3,}:?(?:(\|:?-{3,}:?)+\|?|\|)$/.test(normalized);
     };
 
     const hasHeader = lines.some(isSeparatorLine);

package/pipeline/markdown-processor.js

@@ -35,7 +35,10 @@ const MARKDOWN_PATTERNS = [
     { regex: /\*\*\+\+(.+?)\+\+\*\*/, format: { bold: true, underline: true } },
     // Bold: **text** or __text__
     { regex: /\*\*(.+?)\*\*/, format: { bold: true } },
-    { regex: /__(.+?)__/, format: { bold: true } },
+    // Underscore delimiters follow CommonMark flanking rules: not intraword, not part of a
+    // longer underscore run, and never around whitespace. So signature lines ("_____")
+    // and snake_case identifiers stay literal text.
+    { regex: /(?<![A-Za-z0-9_])__(?=[^_\s])(.+?)(?<=[^_\s])__(?![A-Za-z0-9_])/, format: { bold: true } },
     // Underline: ++text++
     { regex: /\+\+(.+?)\+\+/, format: { underline: true } },
     // Strikethrough: ~~text~~ or ~text~
@@ -43,7 +46,7 @@ const MARKDOWN_PATTERNS = [
     { regex: /~(.+?)~/, format: { strikethrough: true } },
     // Italic: *text* or _text_ (using lookahead only for compatibility)
     { regex: /\*(?!\*)(.+?)\*(?!\*)/, format: { italic: true } },
-    { regex: /_(?!_)(.+?)_(?!_)/, format: { italic: true } }
+    { regex: /(?<![A-Za-z0-9_])_(?=[^_\s])(.+?)(?<=[^_\s])_(?![A-Za-z0-9_])/, format: { italic: true } }
 ];
 
 /**

package/pipeline/structured-content.js

@@ -9,7 +9,8 @@
 
 import { matchListMarker } from './list-markers.js';
 
-const TABLE_SEPARATOR = /^\s*\|?\s*:?-{3,}:?\s*(?:\|\s*:?-{3,}:?\s*)+\|?\s*$/;
+// A one-column separator needs a pipe on both sides ("| --- |"); two or more columns as before.
+const TABLE_SEPARATOR = /^\s*(?:\|\s*:?-{3,}:?\s*\||\|?\s*:?-{3,}:?\s*(?:\|\s*:?-{3,}:?\s*)+\|?)\s*$/;
 
 function isBlank(line) {
     return !line || line.trim().length === 0;

package/services/comment-parts-merge.js

@@ -0,0 +1,124 @@
+/**
+ * Parts-level comment merge: the comment half of writing a batch result back into a
+ * package, for hosts that hold package parts as XML strings rather than a ZIP (a Flat OPC
+ * package, a browser parts map). Strings in, strings out; no package, relationship or
+ * content-type handling, which stays with the host.
+ */
+
+import { mergeCommentsPartXml, parseXmlStrictStandalone } from './standalone-docx-plumbing.js';
+import { reconcileCommentSiblingParts } from './comment-thread-parts.js';
+
+const PART_KEYS = Object.freeze({
+    comments: 'commentsXml',
+    commentsExtended: 'commentsExtendedXml',
+    commentsIds: 'commentsIdsXml',
+    commentsExtensible: 'commentsExtensibleXml'
+});
+
+const partsOf = parts => Object.fromEntries(Object.values(PART_KEYS).map(key => [key, parts?.[key] || null]));
+
+/**
+ * Merges a batch result's comment output into a package's comment parts.
+ *
+ * - `commentsXml` is appended to the existing comments part (`commentsXmlMode: 'merge'`, the default) or replaces it
+ *   (`'replace'`). commentsIds.xml and commentsExtensible.xml, when the package has them, are then brought in line with
+ *   comments.xml; they are never created.
+ * - `commentsExtendedXml` replaces the thread-metadata part. A `'merge'` delta for a package that already has
+ *   commentsExtended.xml cannot be merged safely and is refused.
+ *
+ * Never throws for document content; on error the input parts are returned unchanged.
+ *
+ * @param {{ commentsXml?: string|null, commentsExtendedXml?: string|null, commentsIdsXml?: string|null, commentsExtensibleXml?: string|null }} parts
+ *   the package's current comment parts (absent parts null or omitted)
+ * @param {{ commentsXml?: string|null, commentsXmlMode?: 'merge'|'replace', commentsExtendedXml?: string|null, commentsExtendedXmlMode?: 'merge'|'replace' }} output
+ *   comment output of a batch, for example an `applyOperationsToDocumentXml` result
+ * @returns {{ status: 'ok'|'error', hasChanges: boolean, parts: { commentsXml: string|null, commentsExtendedXml: string|null, commentsIdsXml: string|null, commentsExtensibleXml: string|null }, changedParts: string[], addedParts: string[], error?: { code: string, message: string, part?: string, commentId?: string } }}
+ *   `changedParts` and `addedParts` name parts as `comments`, `commentsExtended`, `commentsIds`, `commentsExtensible`;
+ *   `addedParts` lists parts the input did not have, which need a relationship and content type. It reflects part
+ *   presence only: relationships are not visible here, so a host that owns them should also repair a missing
+ *   relationship for any part in `changedParts`.
+ */
+export function mergeCommentParts(parts = {}, output = {}) {
+    const before = partsOf(parts);
+    const after = { ...before };
+    const fail = error => ({ status: 'error', hasChanges: false, parts: before, changedParts: [], addedParts: [], error });
+    const commentsMode = output?.commentsXmlMode === 'replace' ? 'replace' : 'merge';
+    const extendedMode = output?.commentsExtendedXmlMode === 'replace' ? 'replace' : 'merge';
+
+    for (const [label, value] of [
+        ...Object.values(PART_KEYS).map(key => [`parts.${key}`, before[key]]),
+        ['output.commentsXml', output?.commentsXml], ['output.commentsExtendedXml', output?.commentsExtendedXml]
+    ]) {
+        if (value != null && typeof value !== 'string') {
+            return fail({ code: 'INVALID_COMMENT_PARTS', message: `${label} must be an XML string, null or omitted (got ${typeof value}).` });
+        }
+    }
+
+    // Parses a part and checks its root element, so a wrong part is refused rather than merged as empty.
+    const requirePart = (xml, part, rootName, label) => {
+        let doc;
+        try {
+            doc = parseXmlStrictStandalone(xml, label);
+        } catch (error) {
+            throw Object.assign(error, { part });
+        }
+        if (doc.documentElement?.localName !== rootName) {
+            throw Object.assign(new Error(`${label}: expected a <${rootName}> root element, found <${doc.documentElement?.localName || 'none'}>.`), { code: 'INVALID_COMMENT_PARTS', part });
+        }
+        return doc;
+    };
+
+    try {
+        if (output?.commentsXml) {
+            const incomingDoc = requirePart(output.commentsXml, 'comments', 'comments', 'word/comments.xml (incoming)');
+            // Ids must be unique within the incoming part in every mode (the merge below also checks them
+            // against the existing part).
+            const seen = new Set();
+            for (const node of Array.from(incomingDoc.getElementsByTagNameNS('*', 'comment'))) {
+                const id = node.getAttribute('w:id') || node.getAttribute('id');
+                if (!id) continue;
+                if (seen.has(id)) {
+                    throw Object.assign(new Error(`Duplicate comment id: ${id}`), { code: 'DUPLICATE_COMMENT_ID', commentId: id, part: 'comments' });
+                }
+                seen.add(id);
+            }
+            if (before.commentsXml) requirePart(before.commentsXml, 'comments', 'comments', 'word/comments.xml (existing)');
+            // Sibling parts are reconciled below; a malformed one would otherwise be skipped silently.
+            if (before.commentsIdsXml) requirePart(before.commentsIdsXml, 'commentsIds', 'commentsIds', 'word/commentsIds.xml (existing)');
+            if (before.commentsExtensibleXml) requirePart(before.commentsExtensibleXml, 'commentsExtensible', 'commentsExtensible', 'word/commentsExtensible.xml (existing)');
+            after.commentsXml = mergeCommentsPartXml(before.commentsXml, output.commentsXml, { replaceExisting: commentsMode === 'replace' });
+            Object.assign(after, reconcileCommentSiblingParts({
+                commentsXml: after.commentsXml,
+                commentsIdsXml: after.commentsIdsXml,
+                commentsExtensibleXml: after.commentsExtensibleXml
+            }));
+        }
+        if (output?.commentsExtendedXml) {
+            if (extendedMode !== 'replace' && before.commentsExtendedXml) {
+                return fail({
+                    code: 'UNSUPPORTED_EXISTING_COMMENT_THREAD_METADATA',
+                    part: 'commentsExtended',
+                    message: 'The output carries a commentsExtended delta (mode "merge") for parts that already have thread metadata; a delta cannot be merged into an existing commentsExtended.xml. Nothing was merged.'
+                });
+            }
+            requirePart(output.commentsExtendedXml, 'commentsExtended', 'commentsEx', 'word/commentsExtended.xml (incoming)');
+            after.commentsExtendedXml = output.commentsExtendedXml;
+        }
+    } catch (error) {
+        return fail({
+            code: error?.code || 'COMMENT_PARTS_MERGE_FAILED',
+            message: error?.message || String(error),
+            ...(error?.part || error?.code === 'DUPLICATE_COMMENT_ID' ? { part: error.part || 'comments' } : {}),
+            ...(error?.commentId ? { commentId: error.commentId } : {})
+        });
+    }
+
+    const changedParts = [];
+    const addedParts = [];
+    for (const [name, key] of Object.entries(PART_KEYS)) {
+        if (after[key] === before[key]) continue;
+        changedParts.push(name);
+        if (!before[key]) addedParts.push(name);
+    }
+    return { status: 'ok', hasChanges: changedParts.length > 0, parts: after, changedParts, addedParts };
+}

package/services/comment-replies.js

@@ -32,7 +32,7 @@ export function applyCommentReplyToParts({ commentsXml, commentsExtendedXml = nu
     }
     const occupied = usedParaIds(commentsDoc, extendedDoc);
     // paraIds are unique across the whole package; body paragraphs can carry them too.
-    if (documentXml) for (const match of String(documentXml).matchAll(/w14:paraId="([0-9A-Fa-f]{8})"/g)) occupied.add(match[1].toUpperCase());
+    if (documentXml) for (const match of String(documentXml).matchAll(/\bw14:paraId="([0-9A-Fa-f]{8})"/g)) occupied.add(match[1].toUpperCase());
     const parentParagraph = commentThreadParagraph(parent);
     if (!parentParagraph) return { status: 'error', error: { code: 'PARENT_COMMENT_INVALID', message: `Parent comment '${parentCommentId}' has no paragraph.` } };
     let parentParaId = commentParaId(parent);

package/services/document-operation-applier.js

@@ -258,6 +258,7 @@ export async function applyOperationToDocumentXml(documentXml, op, author, runti
         ...(operation.existingRevisions ? { existingRevisions: operation.existingRevisions } : {}),
         structuredContent: typeof operation.structuredContent === 'boolean' ? operation.structuredContent : (options.structuredContent !== false),
         explicitStructuredContent: operation.structuredContent === true,
+        plainTextContent: operation.structuredContent === false || (operation.structuredContent == null && options.structuredContent === false),
         ...(operation._localizedReplacementCompilation && operation.structuredContent !== true ? { literalTextEdit: true } : {}),
         pairReplacements: typeof operation.pairReplacements === 'boolean' ? operation.pairReplacements : (options.pairReplacements !== false),
         ...(operation.insertionAffinity ? { insertionAffinity: operation.insertionAffinity } : {}),

package/services/document-operation-contract.js

@@ -28,6 +28,7 @@ const SUPPORTED_OPERATION_TYPES = new Set([
 ]);
 
 export const EXISTING_REVISIONS_POLICIES = Object.freeze([
+    'auto',
     'merge-same-author',
     'slice-cross-author',
     'reject-input',