matrix-react-sdk
Version:
SDK for matrix.org using React
342 lines (279 loc) • 39.8 kB
JavaScript
"use strict";
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 _HtmlUtils = require("../HtmlUtils");
/*
Copyright 2019 The Matrix.org Foundation C.I.C.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
const decodeEntities = function () {
let textarea = null;
return function (string) {
if (!textarea) {
textarea = document.createElement("textarea");
}
textarea.innerHTML = string;
return textarea.value;
};
}();
function textToHtml(text) {
const container = document.createElement("div");
container.textContent = text;
return container.innerHTML;
}
function getSanitizedHtmlBody(content) {
const opts = {
stripReplyFallback: true,
returnString: 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) {
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 diffTreeToDOM(desc) {
if (desc.nodeName === "#text") {
return stringAsTextNode(desc.data);
} else {
const node = document.createElement(desc.nodeName);
if (desc.attributes) {
for (const [key, value] of Object.entries(desc.attributes)) {
node.setAttribute(key, 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(decodeEntities(string));
}
function renderDifferenceInDOM(originalRootNode, diff, diffMathPatch) {
const {
refNode,
refParentNode
} = findRefNodes(originalRootNode, diff.route);
switch (diff.action) {
case "replaceElement":
{
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":
{
const delNode = wrapDeletion(stringAsTextNode(diff.value));
refNode.parentNode.replaceChild(delNode, refNode);
break;
}
case "removeElement":
{
const delNode = wrapDeletion(diffTreeToDOM(diff.element));
refNode.parentNode.replaceChild(delNode, refNode);
break;
}
case "modifyTextElement":
{
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":
{
const insNode = wrapInsertion(diffTreeToDOM(diff.element));
insertBefore(refParentNode, refNode, insNode);
break;
}
case "addTextElement":
{
// 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":
{
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, ???)
console.warn("MessageDiffUtils::editBodyDiffToHtml: diff action not supported atm", diff);
}
}
function routeIsEqual(r1, r2) {
return r1.length === r2.length && !r1.some((e, i) => e !== r2[i]);
} // workaround for https://github.com/fiduswriter/diffDOM/issues/90
function filterCancelingOutDiffs(originalDiffActions) {
const diffActions = originalDiffActions.slice();
for (let i = 0; i < diffActions.length; ++i) {
const diff = diffActions[i];
if (diff.action === "removeTextElement") {
const nextDiff = diffActions[i + 1];
const cancelsOut = nextDiff && nextDiff.action === "addTextElement" && nextDiff.text === diff.text && routeIsEqual(nextDiff.route, diff.route);
if (cancelsOut) {
diffActions.splice(i, 2);
}
}
}
return diffActions;
}
/**
* Renders a message with the changes made in an edit shown visually.
* @param {object} originalContent the content for the base message
* @param {object} editContent the content for the edit message
* @return {object} 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 originaldiffActions = dd.diff(originalBody, editBody); // work around https://github.com/fiduswriter/diffDOM/issues/90
const diffActions = filterCancelingOutDiffs(originaldiffActions); // 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,"sources":["../../src/utils/MessageDiffUtils.js"],"names":["decodeEntities","textarea","string","document","createElement","innerHTML","value","textToHtml","text","container","textContent","getSanitizedHtmlBody","content","opts","stripReplyFallback","returnString","format","wrapInsertion","child","wrapper","className","appendChild","wrapDeletion","findRefNodes","root","route","isAddition","refNode","refParentNode","end","length","i","childNodes","diffTreeToDOM","desc","nodeName","stringAsTextNode","data","node","attributes","key","Object","entries","setAttribute","childDesc","insertBefore","parent","nextSibling","isRouteOfNextSibling","route1","route2","lastD1Idx","adjustRoutes","diff","remainingDiffs","action","advance","rd","createTextNode","renderDifferenceInDOM","originalRootNode","diffMathPatch","delNode","oldValue","insNode","newValue","parentNode","replaceChild","element","textDiffs","diff_main","diff_cleanupSemantic","modifier","textDiffNode","cloneNode","updatedNode","name","removeAttribute","console","warn","routeIsEqual","r1","r2","some","e","filterCancelingOutDiffs","originalDiffActions","diffActions","slice","nextDiff","cancelsOut","splice","editBodyDiffToHtml","originalContent","editContent","originalBody","editBody","dd","DiffDOM","originaldiffActions","DiffMatchPatch","DOMParser","parseFromString","body","children","safeBody","__html"],"mappings":"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","sourcesContent":["/*\nCopyright 2019 The Matrix.org Foundation C.I.C.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");\nyou may not use this file except in compliance with the License.\nYou may obtain a copy of the License at\n\n    http://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\nSee the License for the specific language governing permissions and\nlimitations under the License.\n*/\n\nimport React from 'react';\nimport classNames from 'classnames';\nimport DiffMatchPatch from 'diff-match-patch';\nimport {DiffDOM} from \"diff-dom\";\nimport { checkBlockNode, bodyToHtml } from \"../HtmlUtils\";\n\nconst decodeEntities = (function() {\n    let textarea = null;\n    return function(string) {\n        if (!textarea) {\n            textarea = document.createElement(\"textarea\");\n        }\n        textarea.innerHTML = string;\n        return textarea.value;\n    };\n})();\n\nfunction textToHtml(text) {\n    const container = document.createElement(\"div\");\n    container.textContent = text;\n    return container.innerHTML;\n}\n\nfunction getSanitizedHtmlBody(content) {\n    const opts = {\n        stripReplyFallback: true,\n        returnString: 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) {\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) {\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(root, route, isAddition) {\n    let refNode = root;\n    let refParentNode;\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 diffTreeToDOM(desc) {\n    if (desc.nodeName === \"#text\") {\n        return stringAsTextNode(desc.data);\n    } else {\n        const node = document.createElement(desc.nodeName);\n        if (desc.attributes) {\n            for (const [key, value] of Object.entries(desc.attributes)) {\n                node.setAttribute(key, value);\n            }\n        }\n        if (desc.childNodes) {\n            for (const childDesc of desc.childNodes) {\n                node.appendChild(diffTreeToDOM(childDesc));\n            }\n        }\n        return node;\n    }\n}\n\nfunction insertBefore(parent, nextSibling, child) {\n    if (nextSibling) {\n        parent.insertBefore(child, nextSibling);\n    } else {\n        parent.appendChild(child);\n    }\n}\n\nfunction isRouteOfNextSibling(route1, route2) {\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, remainingDiffs) {\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) {\n    return document.createTextNode(decodeEntities(string));\n}\n\nfunction renderDifferenceInDOM(originalRootNode, diff, diffMathPatch) {\n    const {refNode, refParentNode} = findRefNodes(originalRootNode, diff.route);\n    switch (diff.action) {\n        case \"replaceElement\": {\n            const container = document.createElement(\"span\");\n            const delNode = wrapDeletion(diffTreeToDOM(diff.oldValue));\n            const insNode = wrapInsertion(diffTreeToDOM(diff.newValue));\n            container.appendChild(delNode);\n            container.appendChild(insNode);\n            refNode.parentNode.replaceChild(container, refNode);\n            break;\n        }\n        case \"removeTextElement\": {\n            const delNode = wrapDeletion(stringAsTextNode(diff.value));\n            refNode.parentNode.replaceChild(delNode, refNode);\n            break;\n        }\n        case \"removeElement\": {\n            const delNode = wrapDeletion(diffTreeToDOM(diff.element));\n            refNode.parentNode.replaceChild(delNode, refNode);\n            break;\n        }\n        case \"modifyTextElement\": {\n            const textDiffs = diffMathPatch.diff_main(diff.oldValue, diff.newValue);\n            diffMathPatch.diff_cleanupSemantic(textDiffs);\n            const container = document.createElement(\"span\");\n            for (const [modifier, text] of textDiffs) {\n                let textDiffNode = 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            const insNode = wrapInsertion(diffTreeToDOM(diff.element));\n            insertBefore(refParentNode, refNode, insNode);\n            break;\n        }\n        case \"addTextElement\": {\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 : \"\"));\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            const delNode = wrapDeletion(refNode.cloneNode(true));\n            const updatedNode = refNode.cloneNode(true);\n            if (diff.action === \"addAttribute\" || diff.action === \"modifyAttribute\") {\n                updatedNode.setAttribute(diff.name, diff.newValue);\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            console.warn(\"MessageDiffUtils::editBodyDiffToHtml: diff action not supported atm\", diff);\n    }\n}\n\nfunction routeIsEqual(r1, r2) {\n    return r1.length === r2.length && !r1.some((e, i) => e !== r2[i]);\n}\n\n// workaround for https://github.com/fiduswriter/diffDOM/issues/90\nfunction filterCancelingOutDiffs(originalDiffActions) {\n    const diffActions = originalDiffActions.slice();\n\n    for (let i = 0; i < diffActions.length; ++i) {\n        const diff = diffActions[i];\n        if (diff.action === \"removeTextElement\") {\n            const nextDiff = diffActions[i + 1];\n            const cancelsOut = nextDiff &&\n                nextDiff.action === \"addTextElement\" &&\n                nextDiff.text === diff.text &&\n                routeIsEqual(nextDiff.route, diff.route);\n\n            if (cancelsOut) {\n                diffActions.splice(i, 2);\n            }\n        }\n    }\n\n    return diffActions;\n}\n\n/**\n * Renders a message with the changes made in an edit shown visually.\n * @param {object} originalContent the content for the base message\n * @param {object} editContent the content for the edit message\n * @return {object} a react element similar to what `bodyToHtml` returns\n */\nexport function editBodyDiffToHtml(originalContent, editContent) {\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 originaldiffActions = dd.diff(originalBody, editBody);\n    // work around https://github.com/fiduswriter/diffDOM/issues/90\n    const diffActions = filterCancelingOutDiffs(originaldiffActions);\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"]}