@dojo-ng/rich-text-criticmarkup 0.1.0

package/dist/transformers.js

@@ -0,0 +1,187 @@
+/**
+ * The five CriticMarkup text-match transformers (Track N2). Order is substitution, deletion,
+ * insertion, highlight, comment — decision 7: `@lexical/markdown`'s import loop tries transformers
+ * in LIST order against the full remaining text and takes the first whose regex matches ANYWHERE in
+ * it, not the one that would have matched earliest. Highlight before comment is load-bearing: an
+ * anchored `{==t==}{>>n<<}` must let the highlight's own regex (which carries the optional trailing
+ * comment group) claim the comment text before a bare-comment transformer listed earlier could steal
+ * it from a highlight elsewhere on the same line.
+ *
+ * No `trigger` on any of these: CriticMarkup marks are authored through toolbar actions and
+ * suggestion mode (Track S/T), not typed markdown shortcuts, and a stray `}` should never silently
+ * spawn a mark.
+ *
+ * These regexes assume the text hitting them has already been through decision 16's pipeline
+ * (`tokenizeBlockSpanning` then `maskNested`, Track N3) — a mark never spans a block by the time a
+ * transformer sees it, and a nested mark's own delimiters are sentinels, not the literal characters
+ * these patterns look for.
+ */
+import { $createTextNode, $isTextNode } from "lexical";
+import { escapeToken, unescapeToken, PARAGRAPH_TOKEN } from "./grammar.js";
+import { $createBreakNode, $isBreakNode, $createCommentNode, $isCommentNode, $createDeletionNode, $isDeletionNode, DeletionNode, $createHighlightNode, $isHighlightNode, HighlightNode, $createInsertionNode, $isInsertionNode, InsertionNode, CommentNode, } from "./nodes.js";
+/**
+ * Split raw mark content around paragraph-token breaks (decision 16) into `TextNode`/`BreakNode`
+ * children, appended to `parent` in order. Every text piece inherits `format`, so a mark sitting
+ * inside bold text stays bold. A doubled (escaped) token is left in the buffer for `unescapeToken`
+ * to fold into one literal character; a lone token flushes the buffer and inserts a break.
+ */
+function appendTokenSegments(parent, content, format) {
+    let buffer = "";
+    let i = 0;
+    const flush = () => {
+        if (buffer === "")
+            return;
+        const t = $createTextNode(unescapeToken(buffer));
+        t.setFormat(format);
+        parent.append(t);
+        buffer = "";
+    };
+    while (i < content.length) {
+        if (content.startsWith(PARAGRAPH_TOKEN, i)) {
+            if (content.startsWith(PARAGRAPH_TOKEN, i + PARAGRAPH_TOKEN.length)) {
+                buffer += PARAGRAPH_TOKEN + PARAGRAPH_TOKEN; // escaped pair — unescaped whole on flush
+                i += PARAGRAPH_TOKEN.length * 2;
+            }
+            else {
+                flush();
+                parent.append($createBreakNode());
+                i += PARAGRAPH_TOKEN.length;
+            }
+        }
+        else {
+            buffer += content[i];
+            i += 1;
+        }
+    }
+    flush();
+}
+/**
+ * The inverse of `appendTokenSegments`, for export: walk `node`'s children, passing each text
+ * piece through `exportFormat` (so `**`/`*` wrapping from active formats is preserved) with its
+ * literal content escaped first, and passing a `BreakNode`'s token straight through unescaped. The
+ * escaping must happen on each piece BEFORE formatting wraps it and must never touch a break's own
+ * token — collapsing to a single `getTextContent()` + `escapeToken()` pass would double-escape (or
+ * silently drop) whichever of the two survives the ambiguity.
+ */
+function exportMarkContent(node, exportFormat) {
+    let out = "";
+    for (const child of node.getChildren()) {
+        if ($isBreakNode(child))
+            out += child.getTextContent();
+        else if ($isTextNode(child))
+            out += exportFormat(child, escapeToken(child.getTextContent()));
+        else
+            out += child.getTextContent();
+    }
+    return out;
+}
+// --- substitution -------------------------------------------------------------------------------
+export const SUBSTITUTION_TRANSFORMER = {
+    dependencies: [DeletionNode, InsertionNode],
+    importRegExp: /\{~~(.*?)~>(.*?)~~\}/,
+    regExp: /\{~~(.*?)~>(.*?)~~\}$/,
+    replace: (textNode, match) => {
+        const [, oldRaw, newRaw] = match;
+        const format = textNode.getFormat();
+        const deletionNode = $createDeletionNode();
+        appendTokenSegments(deletionNode, oldRaw, format);
+        const insertionNode = $createInsertionNode();
+        appendTokenSegments(insertionNode, newRaw, format);
+        textNode.replace(deletionNode);
+        deletionNode.insertAfter(insertionNode);
+    },
+    type: "text-match",
+};
+// --- deletion -------------------------------------------------------------------------------------
+export const DELETION_TRANSFORMER = {
+    dependencies: [DeletionNode],
+    importRegExp: /\{--(.*?)--\}/,
+    regExp: /\{--(.*?)--\}$/,
+    replace: (textNode, match) => {
+        const [, raw] = match;
+        const node = $createDeletionNode();
+        appendTokenSegments(node, raw, textNode.getFormat());
+        textNode.replace(node);
+    },
+    export: (node, _exportChildren, exportFormat) => {
+        if (!$isDeletionNode(node))
+            return null;
+        // Decision 4, half one: when an insertion immediately follows, this is a substitution pair —
+        // emit nothing here and let the insertion below emit the combined `{~~old~>new~~}`. Either
+        // half emitting alone would produce the pair twice or not at all.
+        if ($isInsertionNode(node.getNextSibling()))
+            return "";
+        return `{--${exportMarkContent(node, exportFormat)}--}`;
+    },
+    type: "text-match",
+};
+// --- insertion ------------------------------------------------------------------------------------
+export const INSERTION_TRANSFORMER = {
+    dependencies: [InsertionNode],
+    importRegExp: /\{\+\+(.*?)\+\+\}/,
+    regExp: /\{\+\+(.*?)\+\+\}$/,
+    replace: (textNode, match) => {
+        const [, raw] = match;
+        const node = $createInsertionNode();
+        appendTokenSegments(node, raw, textNode.getFormat());
+        textNode.replace(node);
+    },
+    export: (node, _exportChildren, exportFormat) => {
+        if (!$isInsertionNode(node))
+            return null;
+        const prev = node.getPreviousSibling();
+        if ($isDeletionNode(prev)) {
+            // Decision 4, half two: the deletion just before emitted "", so the combined pair is
+            // emitted here instead of a lone insertion.
+            return `{~~${exportMarkContent(prev, exportFormat)}~>${exportMarkContent(node, exportFormat)}~~}`;
+        }
+        return `{++${exportMarkContent(node, exportFormat)}++}`;
+    },
+    type: "text-match",
+};
+// --- highlight (with an optional anchored comment) -------------------------------------------------
+export const HIGHLIGHT_TRANSFORMER = {
+    dependencies: [HighlightNode],
+    importRegExp: /\{==(.*?)==\}(?:\{>>(.*?)<<\})?/,
+    regExp: /\{==(.*?)==\}(?:\{>>(.*?)<<\})?$/,
+    replace: (textNode, match) => {
+        const [, raw, commentRaw] = match;
+        const node = $createHighlightNode();
+        appendTokenSegments(node, raw, textNode.getFormat());
+        if (commentRaw !== undefined)
+            node.setComment(unescapeToken(commentRaw));
+        textNode.replace(node);
+    },
+    export: (node, _exportChildren, exportFormat) => {
+        if (!$isHighlightNode(node))
+            return null;
+        const comment = node.getComment();
+        const commentPart = comment !== null ? `{>>${escapeToken(comment)}<<}` : "";
+        return `{==${exportMarkContent(node, exportFormat)}==}${commentPart}`;
+    },
+    type: "text-match",
+};
+// --- comment (bare only — an anchored one is consumed above, by the highlight transformer) --------
+export const COMMENT_TRANSFORMER = {
+    dependencies: [CommentNode],
+    importRegExp: /\{>>(.*?)<<\}/,
+    regExp: /\{>>(.*?)<<\}$/,
+    replace: (textNode, match) => {
+        const [, raw] = match;
+        textNode.replace($createCommentNode(unescapeToken(raw)));
+    },
+    export: (node) => {
+        if (!$isCommentNode(node))
+            return null;
+        return `{>>${escapeToken(node.getText())}<<}`;
+    },
+    type: "text-match",
+};
+/** The five transformers in decision 7's required order. */
+export const criticMarkupTransformers = [
+    SUBSTITUTION_TRANSFORMER,
+    DELETION_TRANSFORMER,
+    INSERTION_TRANSFORMER,
+    HIGHLIGHT_TRANSFORMER,
+    COMMENT_TRANSFORMER,
+];

package/fixtures/conformance.json

@@ -0,0 +1,67 @@
+[
+	{ "id": "parse-insertion", "op": "parse", "input": "{++foo++}",
+		"expected": [ { "kind": "insertion", "start": 0, "end": 9, "text": "foo", "spansBlock": false, "nested": false } ] },
+	{ "id": "parse-deletion", "op": "parse", "input": "{--bar--}",
+		"expected": [ { "kind": "deletion", "start": 0, "end": 9, "text": "bar", "spansBlock": false, "nested": false } ] },
+	{ "id": "parse-substitution", "op": "parse", "input": "{~~old~>new~~}",
+		"expected": [ { "kind": "substitution", "start": 0, "end": 14, "old": "old", "new": "new", "spansBlock": false, "nested": false } ] },
+	{ "id": "parse-comment", "op": "parse", "input": "{>>note<<}",
+		"expected": [ { "kind": "comment", "start": 0, "end": 10, "text": "note", "spansBlock": false, "nested": false } ] },
+	{ "id": "parse-highlight", "op": "parse", "input": "{==hl==}",
+		"expected": [ { "kind": "highlight", "start": 0, "end": 8, "text": "hl", "spansBlock": false, "nested": false } ] },
+	{ "id": "parse-nested-same-kind", "op": "parse", "input": "{--a {--b--} c--}",
+		"expected": [
+			{ "kind": "deletion", "start": 0, "end": 17, "text": "a {--b--} c", "spansBlock": false, "nested": true },
+			{ "kind": "deletion", "start": 5, "end": 12, "text": "b", "spansBlock": false, "nested": false }
+		] },
+	{ "id": "parse-nested-different-kind", "op": "parse", "input": "{++a {--b--} c++}",
+		"expected": [
+			{ "kind": "insertion", "start": 0, "end": 17, "text": "a {--b--} c", "spansBlock": false, "nested": true },
+			{ "kind": "deletion", "start": 5, "end": 12, "text": "b", "spansBlock": false, "nested": false }
+		] },
+	{ "id": "parse-unterminated", "op": "parse", "input": "{++foo", "expected": [] },
+	{ "id": "parse-fenced-code-skip", "op": "parse", "input": "```\n{--not tracked--}\n```", "expected": [] },
+	{ "id": "parse-reading-order", "op": "parse", "input": "{++a++}{--b--}{==c==}",
+		"expected": [
+			{ "kind": "insertion", "start": 0, "end": 7, "text": "a", "spansBlock": false, "nested": false },
+			{ "kind": "deletion", "start": 7, "end": 14, "text": "b", "spansBlock": false, "nested": false },
+			{ "kind": "highlight", "start": 14, "end": 21, "text": "c", "spansBlock": false, "nested": false }
+		] },
+	{ "id": "parse-spans-block", "op": "parse", "input": "{++A\n\nB++}",
+		"expected": [ { "kind": "insertion", "start": 0, "end": 10, "text": "A\n\nB", "spansBlock": true, "nested": false } ] },
+
+	{ "id": "accept-insertion", "op": "accept", "input": "{++foo++}", "mark": 0, "expected": "foo" },
+	{ "id": "decline-insertion", "op": "decline", "input": "{++foo++}", "mark": 0, "expected": "" },
+	{ "id": "accept-deletion", "op": "accept", "input": "{--bar--}", "mark": 0, "expected": "" },
+	{ "id": "decline-deletion", "op": "decline", "input": "{--bar--}", "mark": 0, "expected": "bar" },
+	{ "id": "accept-substitution", "op": "accept", "input": "{~~old~>new~~}", "mark": 0, "expected": "new" },
+	{ "id": "decline-substitution", "op": "decline", "input": "{~~old~>new~~}", "mark": 0, "expected": "old" },
+	{ "id": "accept-highlight-bare", "op": "accept", "input": "{==hl==}", "mark": 0, "expected": "hl" },
+	{ "id": "decline-highlight-bare", "op": "decline", "input": "{==hl==}", "mark": 0, "expected": "hl" },
+	{ "id": "accept-comment-bare", "op": "accept", "input": "{>>note<<}", "mark": 0, "expected": "{>>note<<}" },
+	{ "id": "decline-comment-bare", "op": "decline", "input": "{>>note<<}", "mark": 0, "expected": "{>>note<<}" },
+	{ "id": "accept-highlight-anchored-comment", "op": "accept", "input": "{==hl==}{>>note<<}", "mark": 0, "expected": "hl" },
+	{ "id": "decline-highlight-anchored-comment", "op": "decline", "input": "{==hl==}{>>note<<}", "mark": 0, "expected": "hl" },
+
+	{ "id": "acceptAll-nested-deletion", "op": "acceptAll", "input": "{--a {--b--} c--}", "expected": "" },
+	{ "id": "declineAll-nested-deletion", "op": "declineAll", "input": "{--a {--b--} c--}", "expected": "a b c" },
+	{ "id": "acceptAll-identity-no-marks", "op": "acceptAll", "input": "plain prose, no marks here.", "expected": "plain prose, no marks here." },
+	{ "id": "declineAll-identity-no-marks", "op": "declineAll", "input": "plain prose, no marks here.", "expected": "plain prose, no marks here." },
+	{ "id": "acceptAll-bare-comment-survives", "op": "acceptAll", "input": "{++x++}{>>note<<}", "expected": "x{>>note<<}" },
+	{ "id": "declineAll-bare-comment-survives", "op": "declineAll", "input": "{++x++}{>>note<<}", "expected": "{>>note<<}" },
+	{ "id": "stripComments-removes-bare-comment", "op": "stripComments", "input": "x{>>note<<}", "expected": "x" },
+
+	{ "id": "token-accept-insertion-break", "op": "accept", "input": "A{++¶++}B", "mark": 0, "expected": "A\n\nB" },
+	{ "id": "token-decline-insertion-break", "op": "decline", "input": "A{++¶++}B", "mark": 0, "expected": "AB" },
+	{ "id": "token-accept-deletion-break", "op": "accept", "input": "A{--¶--}B", "mark": 0, "expected": "AB" },
+	{ "id": "token-decline-deletion-break", "op": "decline", "input": "A{--¶--}B", "mark": 0, "expected": "A\n\nB" },
+	{ "id": "token-decline-insertion-no-orphan-blank-line", "op": "decline", "input": "{++A¶B++}", "mark": 0, "expected": "" },
+	{ "id": "token-accept-insertion-content-break", "op": "accept", "input": "{++A¶B++}", "mark": 0, "expected": "A\n\nB" },
+	{ "id": "token-accept-doubled-pilcrow-literal", "op": "accept", "input": "{++A¶¶B++}", "mark": 0, "expected": "A¶B" },
+
+	{ "id": "tokenize-insertion-block-spanning", "op": "tokenize", "input": "{++A\n\nB++}", "expected": "{++A¶B++}" },
+	{ "id": "tokenize-substitution-block-spanning", "op": "tokenize", "input": "{~~A\n\nB~>C~~}", "expected": "{~~A¶B~>C~~}" },
+
+	{ "id": "portable-insertion-tokenized-to-split", "op": "portable", "input": "{++A¶B++}", "expected": "{++A++}\n\n{++B++}" },
+	{ "id": "declineAll-portable-split-blank-line-cost", "op": "declineAll", "input": "{++A++}\n\n{++B++}", "expected": "\n\n" }
+]

package/package.json

@@ -0,0 +1,5 @@
+{ "name": "@dojo-ng/rich-text-criticmarkup", "version": "0.1.0", "license": "BSD-3-Clause", "description": "CriticMarkup tracked-changes plugin for @dojo-ng/rich-text", "type": "module",
+  "main": "./dist/index.js", "module": "./dist/index.js", "types": "./dist/index.d.ts",
+  "files": ["dist", "!dist/**/*.map", "fixtures"],
+  "scripts": { "build": "tsc -p tsconfig.json", "clean": "rm -rf dist" },
+  "dependencies": { "@dojo-ng/rich-text": "^0.1.0", "@dojo-ng/i18n": "^0.1.0", "@dojo-ng/popup-confirmation": "^0.1.0", "@dojo-ng/popup": "^0.1.0", "@dojo-ng/text-area": "^0.1.0", "@dojo-ng/button": "^0.1.0", "lexical": "^0.21.0", "@lexical/markdown": "^0.21.0", "@lexical/utils": "^0.21.0", "lit": "^3.3.0" } }