matrix-react-sdk
Version:
SDK for matrix.org using React
287 lines (281 loc) • 39.1 kB
JavaScript
;
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.editBodyDiffToHtml = editBodyDiffToHtml;
var _react = _interopRequireDefault(require("react"));
var _classnames = _interopRequireDefault(require("classnames"));
var _diffMatchPatch = _interopRequireDefault(require("diff-match-patch"));
var _diffDom = require("diff-dom");
var _logger = require("matrix-js-sdk/src/logger");
var _lodash = require("lodash");
var _HtmlUtils = require("../HtmlUtils");
/*
Copyright 2024 New Vector Ltd.
Copyright 2019-2021 , 2023 The Matrix.org Foundation C.I.C.
SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only
Please see LICENSE files in the repository root for full details.
*/
function textToHtml(text) {
const container = document.createElement("div");
container.textContent = text;
return container.innerHTML;
}
function getSanitizedHtmlBody(content) {
const opts = {
stripReplyFallback: true
};
if (content.format === "org.matrix.custom.html") {
return (0, _HtmlUtils.bodyToHtml)(content, null, opts);
} else {
// convert the string to something that can be safely
// embedded in an html document, e.g. use html entities where needed
// This is also needed so that DiffDOM wouldn't interpret something
// as a tag when somebody types e.g. "</sarcasm>"
// as opposed to bodyToHtml, here we also render
// text messages with dangerouslySetInnerHTML, to unify
// the code paths and because we need html to show differences
return textToHtml((0, _HtmlUtils.bodyToHtml)(content, null, opts));
}
}
function wrapInsertion(child) {
const wrapper = document.createElement((0, _HtmlUtils.checkBlockNode)(child) ? "div" : "span");
wrapper.className = "mx_EditHistoryMessage_insertion";
wrapper.appendChild(child);
return wrapper;
}
function wrapDeletion(child) {
const wrapper = document.createElement((0, _HtmlUtils.checkBlockNode)(child) ? "div" : "span");
wrapper.className = "mx_EditHistoryMessage_deletion";
wrapper.appendChild(child);
return wrapper;
}
function findRefNodes(root, route, isAddition = false) {
let refNode = root;
let refParentNode;
const end = isAddition ? route.length - 1 : route.length;
for (let i = 0; i < end; ++i) {
refParentNode = refNode;
refNode = refNode?.childNodes[route[i]];
}
return {
refNode,
refParentNode
};
}
function isTextNode(node) {
return node.nodeName === "#text";
}
function diffTreeToDOM(desc) {
if (isTextNode(desc)) {
return stringAsTextNode(desc.data);
} else {
const node = document.createElement(desc.nodeName);
for (const [key, value] of Object.entries(desc.attributes)) {
node.setAttribute(key, value.value);
}
if (desc.childNodes) {
for (const childDesc of desc.childNodes) {
node.appendChild(diffTreeToDOM(childDesc));
}
}
return node;
}
}
function insertBefore(parent, nextSibling, child) {
if (nextSibling) {
parent.insertBefore(child, nextSibling);
} else {
parent.appendChild(child);
}
}
function isRouteOfNextSibling(route1, route2) {
// routes are arrays with indices,
// to be interpreted as a path in the dom tree
// ensure same parent
for (let i = 0; i < route1.length - 1; ++i) {
if (route1[i] !== route2[i]) {
return false;
}
}
// the route2 is only affected by the diff of route1
// inserting an element if the index at the level of the
// last element of route1 being larger
// (e.g. coming behind route1 at that level)
const lastD1Idx = route1.length - 1;
return route2[lastD1Idx] >= route1[lastD1Idx];
}
function adjustRoutes(diff, remainingDiffs) {
if (diff.action === "removeTextElement" || diff.action === "removeElement") {
// as removed text is not removed from the html, but marked as deleted,
// we need to readjust indices that assume the current node has been removed.
const advance = 1;
for (const rd of remainingDiffs) {
if (isRouteOfNextSibling(diff.route, rd.route)) {
rd.route[diff.route.length - 1] += advance;
}
}
}
}
function stringAsTextNode(string) {
return document.createTextNode((0, _lodash.unescape)(string));
}
function renderDifferenceInDOM(originalRootNode, diff, diffMathPatch) {
const {
refNode,
refParentNode
} = findRefNodes(originalRootNode, diff.route);
switch (diff.action) {
case "replaceElement":
{
if (!refNode) {
console.warn("Unable to apply replaceElement operation due to missing node");
return;
}
const container = document.createElement("span");
const delNode = wrapDeletion(diffTreeToDOM(diff.oldValue));
const insNode = wrapInsertion(diffTreeToDOM(diff.newValue));
container.appendChild(delNode);
container.appendChild(insNode);
refNode.parentNode.replaceChild(container, refNode);
break;
}
case "removeTextElement":
{
if (!refNode) {
console.warn("Unable to apply removeTextElement operation due to missing node");
return;
}
const delNode = wrapDeletion(stringAsTextNode(diff.value));
refNode.parentNode.replaceChild(delNode, refNode);
break;
}
case "removeElement":
{
if (!refNode) {
console.warn("Unable to apply removeElement operation due to missing node");
return;
}
const delNode = wrapDeletion(diffTreeToDOM(diff.element));
refNode.parentNode.replaceChild(delNode, refNode);
break;
}
case "modifyTextElement":
{
if (!refNode) {
console.warn("Unable to apply modifyTextElement operation due to missing node");
return;
}
const textDiffs = diffMathPatch.diff_main(diff.oldValue, diff.newValue);
diffMathPatch.diff_cleanupSemantic(textDiffs);
const container = document.createElement("span");
for (const [modifier, text] of textDiffs) {
let textDiffNode = stringAsTextNode(text);
if (modifier < 0) {
textDiffNode = wrapDeletion(textDiffNode);
} else if (modifier > 0) {
textDiffNode = wrapInsertion(textDiffNode);
}
container.appendChild(textDiffNode);
}
refNode.parentNode.replaceChild(container, refNode);
break;
}
case "addElement":
{
if (!refParentNode) {
console.warn("Unable to apply addElement operation due to missing node");
return;
}
const insNode = wrapInsertion(diffTreeToDOM(diff.element));
insertBefore(refParentNode, refNode, insNode);
break;
}
case "addTextElement":
{
if (!refParentNode) {
console.warn("Unable to apply addTextElement operation due to missing node");
return;
}
// XXX: sometimes diffDOM says insert a newline when there shouldn't be one
// but we must insert the node anyway so that we don't break the route child IDs.
// See https://github.com/fiduswriter/diffDOM/issues/100
const insNode = wrapInsertion(stringAsTextNode(diff.value !== "\n" ? diff.value : ""));
insertBefore(refParentNode, refNode, insNode);
break;
}
// e.g. when changing a the href of a link,
// show the link with old href as removed and with the new href as added
case "removeAttribute":
case "addAttribute":
case "modifyAttribute":
{
if (!refNode) {
console.warn(`Unable to apply ${diff.action} operation due to missing node`);
return;
}
const delNode = wrapDeletion(refNode.cloneNode(true));
const updatedNode = refNode.cloneNode(true);
if (diff.action === "addAttribute" || diff.action === "modifyAttribute") {
updatedNode.setAttribute(diff.name, diff.newValue);
} else {
updatedNode.removeAttribute(diff.name);
}
const insNode = wrapInsertion(updatedNode);
const container = document.createElement((0, _HtmlUtils.checkBlockNode)(refNode) ? "div" : "span");
container.appendChild(delNode);
container.appendChild(insNode);
refNode.parentNode.replaceChild(container, refNode);
break;
}
default:
// Should not happen (modifyComment, ???)
_logger.logger.warn("MessageDiffUtils::editBodyDiffToHtml: diff action not supported atm", diff);
}
}
/**
* Renders a message with the changes made in an edit shown visually.
* @param {IContent} originalContent the content for the base message
* @param {IContent} editContent the content for the edit message
* @return {JSX.Element} a react element similar to what `bodyToHtml` returns
*/
function editBodyDiffToHtml(originalContent, editContent) {
// wrap the body in a div, DiffDOM needs a root element
const originalBody = `<div>${getSanitizedHtmlBody(originalContent)}</div>`;
const editBody = `<div>${getSanitizedHtmlBody(editContent)}</div>`;
const dd = new _diffDom.DiffDOM();
// diffActions is an array of objects with at least a `action` and `route`
// property. `action` tells us what the diff object changes, and `route` where.
// `route` is a path on the DOM tree expressed as an array of indices.
const diffActions = dd.diff(originalBody, editBody);
// for diffing text fragments
const diffMathPatch = new _diffMatchPatch.default();
// parse the base html message as a DOM tree, to which we'll apply the differences found.
// fish out the div in which we wrapped the messages above with children[0].
const originalRootNode = new DOMParser().parseFromString(originalBody, "text/html").body.children[0];
for (let i = 0; i < diffActions.length; ++i) {
const diff = diffActions[i];
renderDifferenceInDOM(originalRootNode, diff, diffMathPatch);
// DiffDOM assumes in subsequent diffs route path that
// the action was applied (e.g. that a removeElement action removed the element).
// This is not the case for us. We render differences in the DOM tree, and don't apply them.
// So we need to adjust the routes of the remaining diffs to account for this.
adjustRoutes(diff, diffActions.slice(i + 1));
}
// take the html out of the modified DOM tree again
const safeBody = originalRootNode.innerHTML;
const className = (0, _classnames.default)({
"mx_EventTile_body": true,
"markdown-body": true
});
return /*#__PURE__*/_react.default.createElement("span", {
key: "body",
className: className,
dangerouslySetInnerHTML: {
__html: safeBody
},
dir: "auto"
});
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_react","_interopRequireDefault","require","_classnames","_diffMatchPatch","_diffDom","_logger","_lodash","_HtmlUtils","textToHtml","text","container","document","createElement","textContent","innerHTML","getSanitizedHtmlBody","content","opts","stripReplyFallback","format","bodyToHtml","wrapInsertion","child","wrapper","checkBlockNode","className","appendChild","wrapDeletion","findRefNodes","root","route","isAddition","refNode","refParentNode","end","length","i","childNodes","isTextNode","node","nodeName","diffTreeToDOM","desc","stringAsTextNode","data","key","value","Object","entries","attributes","setAttribute","childDesc","insertBefore","parent","nextSibling","isRouteOfNextSibling","route1","route2","lastD1Idx","adjustRoutes","diff","remainingDiffs","action","advance","rd","string","createTextNode","unescape","renderDifferenceInDOM","originalRootNode","diffMathPatch","console","warn","delNode","oldValue","insNode","newValue","parentNode","replaceChild","element","textDiffs","diff_main","diff_cleanupSemantic","modifier","textDiffNode","cloneNode","updatedNode","name","removeAttribute","logger","editBodyDiffToHtml","originalContent","editContent","originalBody","editBody","dd","DiffDOM","diffActions","DiffMatchPatch","DOMParser","parseFromString","body","children","slice","safeBody","classNames","default","dangerouslySetInnerHTML","__html","dir"],"sources":["../../src/utils/MessageDiffUtils.tsx"],"sourcesContent":["/*\nCopyright 2024 New Vector Ltd.\nCopyright 2019-2021 , 2023 The Matrix.org Foundation C.I.C.\n\nSPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only\nPlease see LICENSE files in the repository root for full details.\n*/\n\nimport React from \"react\";\nimport classNames from \"classnames\";\nimport DiffMatchPatch from \"diff-match-patch\";\nimport { DiffDOM, IDiff } from \"diff-dom\";\nimport { IContent } from \"matrix-js-sdk/src/matrix\";\nimport { logger } from \"matrix-js-sdk/src/logger\";\nimport { unescape } from \"lodash\";\n\nimport { bodyToHtml, checkBlockNode, EventRenderOpts } from \"../HtmlUtils\";\n\nfunction textToHtml(text: string): string {\n    const container = document.createElement(\"div\");\n    container.textContent = text;\n    return container.innerHTML;\n}\n\nfunction getSanitizedHtmlBody(content: IContent): string {\n    const opts: EventRenderOpts = {\n        stripReplyFallback: true,\n    };\n    if (content.format === \"org.matrix.custom.html\") {\n        return bodyToHtml(content, null, opts);\n    } else {\n        // convert the string to something that can be safely\n        // embedded in an html document, e.g. use html entities where needed\n        // This is also needed so that DiffDOM wouldn't interpret something\n        // as a tag when somebody types e.g. \"</sarcasm>\"\n\n        // as opposed to bodyToHtml, here we also render\n        // text messages with dangerouslySetInnerHTML, to unify\n        // the code paths and because we need html to show differences\n        return textToHtml(bodyToHtml(content, null, opts));\n    }\n}\n\nfunction wrapInsertion(child: Node): HTMLElement {\n    const wrapper = document.createElement(checkBlockNode(child) ? \"div\" : \"span\");\n    wrapper.className = \"mx_EditHistoryMessage_insertion\";\n    wrapper.appendChild(child);\n    return wrapper;\n}\n\nfunction wrapDeletion(child: Node): HTMLElement {\n    const wrapper = document.createElement(checkBlockNode(child) ? \"div\" : \"span\");\n    wrapper.className = \"mx_EditHistoryMessage_deletion\";\n    wrapper.appendChild(child);\n    return wrapper;\n}\n\nfunction findRefNodes(\n    root: Node,\n    route: number[],\n    isAddition = false,\n): {\n    refNode: Node | undefined;\n    refParentNode: Node | undefined;\n} {\n    let refNode: Node | undefined = root;\n    let refParentNode: Node | undefined;\n    const end = isAddition ? route.length - 1 : route.length;\n    for (let i = 0; i < end; ++i) {\n        refParentNode = refNode;\n        refNode = refNode?.childNodes[route[i]!];\n    }\n    return { refNode, refParentNode };\n}\n\nfunction isTextNode(node: Text | HTMLElement): node is Text {\n    return node.nodeName === \"#text\";\n}\n\nfunction diffTreeToDOM(desc: Text | HTMLElement): Node {\n    if (isTextNode(desc)) {\n        return stringAsTextNode(desc.data);\n    } else {\n        const node = document.createElement(desc.nodeName);\n        for (const [key, value] of Object.entries(desc.attributes)) {\n            node.setAttribute(key, value.value);\n        }\n        if (desc.childNodes) {\n            for (const childDesc of desc.childNodes) {\n                node.appendChild(diffTreeToDOM(childDesc as Text | HTMLElement));\n            }\n        }\n        return node;\n    }\n}\n\nfunction insertBefore(parent: Node, nextSibling: Node | undefined, child: Node): void {\n    if (nextSibling) {\n        parent.insertBefore(child, nextSibling);\n    } else {\n        parent.appendChild(child);\n    }\n}\n\nfunction isRouteOfNextSibling(route1: number[], route2: number[]): boolean {\n    // routes are arrays with indices,\n    // to be interpreted as a path in the dom tree\n\n    // ensure same parent\n    for (let i = 0; i < route1.length - 1; ++i) {\n        if (route1[i] !== route2[i]) {\n            return false;\n        }\n    }\n    // the route2 is only affected by the diff of route1\n    // inserting an element if the index at the level of the\n    // last element of route1 being larger\n    // (e.g. coming behind route1 at that level)\n    const lastD1Idx = route1.length - 1;\n    return route2[lastD1Idx]! >= route1[lastD1Idx]!;\n}\n\nfunction adjustRoutes(diff: IDiff, remainingDiffs: IDiff[]): void {\n    if (diff.action === \"removeTextElement\" || diff.action === \"removeElement\") {\n        // as removed text is not removed from the html, but marked as deleted,\n        // we need to readjust indices that assume the current node has been removed.\n        const advance = 1;\n        for (const rd of remainingDiffs) {\n            if (isRouteOfNextSibling(diff.route, rd.route)) {\n                rd.route[diff.route.length - 1] += advance;\n            }\n        }\n    }\n}\n\nfunction stringAsTextNode(string: string): Text {\n    return document.createTextNode(unescape(string));\n}\n\nfunction renderDifferenceInDOM(originalRootNode: Node, diff: IDiff, diffMathPatch: DiffMatchPatch): void {\n    const { refNode, refParentNode } = findRefNodes(originalRootNode, diff.route);\n\n    switch (diff.action) {\n        case \"replaceElement\": {\n            if (!refNode) {\n                console.warn(\"Unable to apply replaceElement operation due to missing node\");\n                return;\n            }\n            const container = document.createElement(\"span\");\n            const delNode = wrapDeletion(diffTreeToDOM(diff.oldValue as HTMLElement));\n            const insNode = wrapInsertion(diffTreeToDOM(diff.newValue as HTMLElement));\n            container.appendChild(delNode);\n            container.appendChild(insNode);\n            refNode.parentNode!.replaceChild(container, refNode);\n            break;\n        }\n        case \"removeTextElement\": {\n            if (!refNode) {\n                console.warn(\"Unable to apply removeTextElement operation due to missing node\");\n                return;\n            }\n            const delNode = wrapDeletion(stringAsTextNode(diff.value as string));\n            refNode.parentNode!.replaceChild(delNode, refNode);\n            break;\n        }\n        case \"removeElement\": {\n            if (!refNode) {\n                console.warn(\"Unable to apply removeElement operation due to missing node\");\n                return;\n            }\n            const delNode = wrapDeletion(diffTreeToDOM(diff.element as HTMLElement));\n            refNode.parentNode!.replaceChild(delNode, refNode);\n            break;\n        }\n        case \"modifyTextElement\": {\n            if (!refNode) {\n                console.warn(\"Unable to apply modifyTextElement operation due to missing node\");\n                return;\n            }\n            const textDiffs = diffMathPatch.diff_main(diff.oldValue as string, diff.newValue as string);\n            diffMathPatch.diff_cleanupSemantic(textDiffs);\n            const container = document.createElement(\"span\");\n            for (const [modifier, text] of textDiffs) {\n                let textDiffNode: Node = stringAsTextNode(text);\n                if (modifier < 0) {\n                    textDiffNode = wrapDeletion(textDiffNode);\n                } else if (modifier > 0) {\n                    textDiffNode = wrapInsertion(textDiffNode);\n                }\n                container.appendChild(textDiffNode);\n            }\n            refNode.parentNode!.replaceChild(container, refNode);\n            break;\n        }\n        case \"addElement\": {\n            if (!refParentNode) {\n                console.warn(\"Unable to apply addElement operation due to missing node\");\n                return;\n            }\n            const insNode = wrapInsertion(diffTreeToDOM(diff.element as HTMLElement));\n            insertBefore(refParentNode, refNode, insNode);\n            break;\n        }\n        case \"addTextElement\": {\n            if (!refParentNode) {\n                console.warn(\"Unable to apply addTextElement operation due to missing node\");\n                return;\n            }\n            // XXX: sometimes diffDOM says insert a newline when there shouldn't be one\n            // but we must insert the node anyway so that we don't break the route child IDs.\n            // See https://github.com/fiduswriter/diffDOM/issues/100\n            const insNode = wrapInsertion(stringAsTextNode(diff.value !== \"\\n\" ? (diff.value as string) : \"\"));\n            insertBefore(refParentNode, refNode, insNode);\n            break;\n        }\n        // e.g. when changing a the href of a link,\n        // show the link with old href as removed and with the new href as added\n        case \"removeAttribute\":\n        case \"addAttribute\":\n        case \"modifyAttribute\": {\n            if (!refNode) {\n                console.warn(`Unable to apply ${diff.action} operation due to missing node`);\n                return;\n            }\n            const delNode = wrapDeletion(refNode.cloneNode(true));\n            const updatedNode = refNode.cloneNode(true) as HTMLElement;\n            if (diff.action === \"addAttribute\" || diff.action === \"modifyAttribute\") {\n                updatedNode.setAttribute(diff.name, diff.newValue as string);\n            } else {\n                updatedNode.removeAttribute(diff.name);\n            }\n            const insNode = wrapInsertion(updatedNode);\n            const container = document.createElement(checkBlockNode(refNode) ? \"div\" : \"span\");\n            container.appendChild(delNode);\n            container.appendChild(insNode);\n            refNode.parentNode!.replaceChild(container, refNode);\n            break;\n        }\n        default:\n            // Should not happen (modifyComment, ???)\n            logger.warn(\"MessageDiffUtils::editBodyDiffToHtml: diff action not supported atm\", diff);\n    }\n}\n\n/**\n * Renders a message with the changes made in an edit shown visually.\n * @param {IContent} originalContent the content for the base message\n * @param {IContent} editContent the content for the edit message\n * @return {JSX.Element} a react element similar to what `bodyToHtml` returns\n */\nexport function editBodyDiffToHtml(originalContent: IContent, editContent: IContent): JSX.Element {\n    // wrap the body in a div, DiffDOM needs a root element\n    const originalBody = `<div>${getSanitizedHtmlBody(originalContent)}</div>`;\n    const editBody = `<div>${getSanitizedHtmlBody(editContent)}</div>`;\n    const dd = new DiffDOM();\n    // diffActions is an array of objects with at least a `action` and `route`\n    // property. `action` tells us what the diff object changes, and `route` where.\n    // `route` is a path on the DOM tree expressed as an array of indices.\n    const diffActions = dd.diff(originalBody, editBody);\n    // for diffing text fragments\n    const diffMathPatch = new DiffMatchPatch();\n    // parse the base html message as a DOM tree, to which we'll apply the differences found.\n    // fish out the div in which we wrapped the messages above with children[0].\n    const originalRootNode = new DOMParser().parseFromString(originalBody, \"text/html\").body.children[0]!;\n    for (let i = 0; i < diffActions.length; ++i) {\n        const diff = diffActions[i]!;\n        renderDifferenceInDOM(originalRootNode, diff, diffMathPatch);\n        // DiffDOM assumes in subsequent diffs route path that\n        // the action was applied (e.g. that a removeElement action removed the element).\n        // This is not the case for us. We render differences in the DOM tree, and don't apply them.\n        // So we need to adjust the routes of the remaining diffs to account for this.\n        adjustRoutes(diff, diffActions.slice(i + 1));\n    }\n    // take the html out of the modified DOM tree again\n    const safeBody = originalRootNode.innerHTML;\n    const className = classNames({\n        \"mx_EventTile_body\": true,\n        \"markdown-body\": true,\n    });\n    return <span key=\"body\" className={className} dangerouslySetInnerHTML={{ __html: safeBody }} dir=\"auto\" />;\n}\n"],"mappings":"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","ignoreList":[]}