729 lines
29 KiB
JavaScript
729 lines
29 KiB
JavaScript
import { describe, test } from "@odoo/hoot";
|
|
import { press } from "@odoo/hoot-dom";
|
|
import { tick } from "@odoo/hoot-mock";
|
|
import { testEditor } from "../_helpers/editor";
|
|
import { insertText, splitBlock } from "../_helpers/user_actions";
|
|
import { unformat } from "../_helpers/format";
|
|
import { MAIN_PLUGINS } from "@html_editor/plugin_sets";
|
|
import { QWebPlugin } from "@html_editor/others/qweb_plugin";
|
|
|
|
describe("Selection collapsed", () => {
|
|
describe("Basic", () => {
|
|
test("should duplicate an empty paragraph", async () => {
|
|
await testEditor({
|
|
contentBefore: "<p>[]<br></p>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<p><br></p><p>[]<br></p>",
|
|
});
|
|
// TODO this cannot actually be tested currently as a
|
|
// backspace/delete in that case is not even detected
|
|
// (no input event to rollback)
|
|
// await testEditor({
|
|
// contentBefore: '<p>[<br>]</p>',
|
|
// stepFunction: splitBlock,
|
|
// contentAfter: '<p><br></p><p>[]<br></p>',
|
|
// });
|
|
await testEditor({
|
|
contentBefore: "<p><br>[]</p>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<p><br></p><p>[]<br></p>",
|
|
});
|
|
});
|
|
|
|
test("should insert an empty paragraph before a paragraph", async () => {
|
|
await testEditor({
|
|
contentBefore: "<p>[]abc</p>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<p><br></p><p>[]abc</p>",
|
|
});
|
|
await testEditor({
|
|
contentBefore: "<p>[] abc</p>",
|
|
stepFunction: splitBlock,
|
|
// JW cAfter: '<p><br></p><p>[]abc</p>',
|
|
contentAfter: "<p><br></p><p>[] abc</p>",
|
|
});
|
|
});
|
|
|
|
test("should split a paragraph in two", async () => {
|
|
await testEditor({
|
|
contentBefore: "<p>ab[]cd</p>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<p>ab</p><p>[]cd</p>",
|
|
});
|
|
await testEditor({
|
|
contentBefore: "<p>ab []cd</p>",
|
|
stepFunction: splitBlock,
|
|
// The space is converted to a non-breaking
|
|
// space so it is visible.
|
|
contentAfter: "<p>ab </p><p>[]cd</p>",
|
|
});
|
|
await testEditor({
|
|
contentBefore: "<p>ab[] cd</p>",
|
|
stepFunction: splitBlock,
|
|
// The space is converted to a non-breaking
|
|
// space so it is visible.
|
|
contentAfter: "<p>ab</p><p>[] cd</p>",
|
|
});
|
|
});
|
|
|
|
test("should insert an empty paragraph after a paragraph", async () => {
|
|
await testEditor({
|
|
contentBefore: "<p>abc[]</p>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<p>abc</p><p>[]<br></p>",
|
|
});
|
|
await testEditor({
|
|
contentBefore: "<p>abc[] </p>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<p>abc</p><p>[]<br></p>",
|
|
});
|
|
});
|
|
test("should split block without afecting the uploaded document link", async () => {
|
|
await testEditor({
|
|
contentBefore: `<p>abc<a href="#" title="document" data-mimetype="application/pdf" class="o_image"></a>[]def</p>`,
|
|
stepFunction: splitBlock,
|
|
contentAfter: `<p>abc<a href="#" title="document" data-mimetype="application/pdf" class="o_image"></a></p><p>[]def</p>`,
|
|
});
|
|
});
|
|
test("should split block without afecting the uploaded document link (2)", async () => {
|
|
await testEditor({
|
|
contentBefore: `<p>abc<a href="#" title="document" data-mimetype="application/pdf" class="o_image"></a>[]</p>`,
|
|
stepFunction: splitBlock,
|
|
contentAfter: `<p>abc<a href="#" title="document" data-mimetype="application/pdf" class="o_image"></a></p><p>[]<br></p>`,
|
|
});
|
|
});
|
|
test("should not split block with conditional template", async () => {
|
|
await testEditor({
|
|
contentBefore: unformat(`
|
|
<h1 t-if="true">
|
|
<t t-out="Hello"></t>
|
|
[]<t t-out="World"></t>
|
|
</h1>
|
|
`),
|
|
stepFunction: splitBlock,
|
|
contentAfter: unformat(`
|
|
<h1 t-if="true">
|
|
<t t-out="Hello"></t>
|
|
<br>
|
|
[]<t t-out="World"></t>
|
|
</h1>
|
|
`),
|
|
config: { Plugins: [...MAIN_PLUGINS, QWebPlugin] },
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("Pre", () => {
|
|
test("should insert a line break within the pre", async () => {
|
|
await testEditor({
|
|
contentBefore: "<pre>ab[]cd</pre>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<pre>ab<br>[]cd</pre>",
|
|
});
|
|
});
|
|
test("should insert a line break within the pre containing inline element", async () => {
|
|
await testEditor({
|
|
contentBefore: "<pre>a<strong>b[]c</strong>d</pre>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<pre>a<strong>b<br>[]c</strong>d</pre>",
|
|
});
|
|
});
|
|
test("should insert a line break within the pre containing inline elementd", async () => {
|
|
await testEditor({
|
|
contentBefore: "<pre><em>a<strong>b[]c</strong>d</em></pre>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<pre><em>a<strong>b<br>[]c</strong>d</em></pre>",
|
|
});
|
|
});
|
|
|
|
test("should insert a new paragraph after the pre", async () => {
|
|
await testEditor({
|
|
contentBefore: "<pre>abc[]</pre>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<pre>abc</pre><p>[]<br></p>",
|
|
});
|
|
});
|
|
test("should insert a new paragraph after the pre containing inline element", async () => {
|
|
await testEditor({
|
|
contentBefore: "<pre>ab<strong>c[]</strong></pre>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<pre>ab<strong>c</strong></pre><p>[]<br></p>",
|
|
});
|
|
});
|
|
test("should insert a new paragraph after the pre containing inline elements", async () => {
|
|
await testEditor({
|
|
contentBefore: "<pre><em>ab<strong>c[]</strong></em></pre>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<pre><em>ab<strong>c</strong></em></pre><p>[]<br></p>",
|
|
});
|
|
});
|
|
|
|
test("should be able to break out of an empty pre", async () => {
|
|
await testEditor({
|
|
contentBefore: "<pre>[]<br></pre>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<pre><br></pre><p>[]<br></p>",
|
|
});
|
|
});
|
|
test("should insert a new line within the pre", async () => {
|
|
await testEditor({
|
|
contentBefore: "<pre><p>abc</p><p>def[]</p></pre>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<pre><p>abc</p><p>def</p><p>[]<br></p></pre>",
|
|
});
|
|
});
|
|
test("should insert a new line after pre", async () => {
|
|
await testEditor({
|
|
contentBefore: "<pre><p>abc</p><p>def</p><p>[]<br></p></pre>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<pre><p>abc</p><p>def</p></pre><p>[]<br></p>",
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("Blockquote", () => {
|
|
test("should insert a new paragraph after the blockquote", async () => {
|
|
await testEditor({
|
|
contentBefore: "<blockquote>abc[]</blockquote>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<blockquote>abc</blockquote><p>[]<br></p>",
|
|
});
|
|
});
|
|
test("should insert a new paragraph after the blockquote containing inline element", async () => {
|
|
await testEditor({
|
|
contentBefore: "<blockquote>ab<strong>c[]</strong></blockquote>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<blockquote>ab<strong>c</strong></blockquote><p>[]<br></p>",
|
|
});
|
|
});
|
|
test("should be able to break out of an empty blockquote", async () => {
|
|
await testEditor({
|
|
contentBefore: "<blockquote>[]<br></blockquote>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<blockquote><br></blockquote><p>[]<br></p>",
|
|
});
|
|
});
|
|
test("should insert a new line within the blockquote", async () => {
|
|
await testEditor({
|
|
contentBefore: "<blockquote><p>abc</p><p>def[]</p></blockquote>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<blockquote><p>abc</p><p>def</p><p>[]<br></p></blockquote>",
|
|
});
|
|
});
|
|
test("should insert a new line after blockquote", async () => {
|
|
await testEditor({
|
|
contentBefore: "<blockquote><p>abc</p><p>def</p><p>[]<br></p></blockquote>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<blockquote><p>abc</p><p>def</p></blockquote><p>[]<br></p>",
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("Consecutive", () => {
|
|
test("should duplicate an empty paragraph twice", async () => {
|
|
await testEditor({
|
|
contentBefore: "<p>[]<br></p>",
|
|
stepFunction: async (editor) => {
|
|
splitBlock(editor);
|
|
splitBlock(editor);
|
|
},
|
|
contentAfter: "<p><br></p><p><br></p><p>[]<br></p>",
|
|
});
|
|
// TODO this cannot actually be tested currently as a
|
|
// backspace/delete in that case is not even detected
|
|
// (no input event to rollback)
|
|
// await testEditor({
|
|
// contentBefore: '<p>[<br>]</p>',
|
|
// stepFunction: async (editor) => {
|
|
// splitBlock(editor);
|
|
// splitBlock(editor);
|
|
// },
|
|
// contentAfter: '<p><br></p><p><br></p><p>[]<br></p>',
|
|
// });
|
|
await testEditor({
|
|
contentBefore: "<p><br>[]</p>",
|
|
stepFunction: async (editor) => {
|
|
splitBlock(editor);
|
|
splitBlock(editor);
|
|
},
|
|
contentAfter: "<p><br></p><p><br></p><p>[]<br></p>",
|
|
});
|
|
});
|
|
|
|
test("should insert two empty paragraphs before a paragraph", async () => {
|
|
await testEditor({
|
|
contentBefore: "<p>[]abc</p>",
|
|
stepFunction: async (editor) => {
|
|
splitBlock(editor);
|
|
splitBlock(editor);
|
|
},
|
|
contentAfter: "<p><br></p><p><br></p><p>[]abc</p>",
|
|
});
|
|
});
|
|
|
|
test("should split a paragraph in three", async () => {
|
|
await testEditor({
|
|
contentBefore: "<p>ab[]cd</p>",
|
|
stepFunction: async (editor) => {
|
|
splitBlock(editor);
|
|
splitBlock(editor);
|
|
},
|
|
contentAfter: "<p>ab</p><p><br></p><p>[]cd</p>",
|
|
});
|
|
});
|
|
|
|
test("should split a paragraph in four", async () => {
|
|
await testEditor({
|
|
contentBefore: "<p>ab[]cd</p>",
|
|
stepFunction: async (editor) => {
|
|
splitBlock(editor);
|
|
splitBlock(editor);
|
|
splitBlock(editor);
|
|
},
|
|
contentAfter: "<p>ab</p><p><br></p><p><br></p><p>[]cd</p>",
|
|
});
|
|
});
|
|
|
|
test("should insert two empty paragraphs after a paragraph", async () => {
|
|
await testEditor({
|
|
contentBefore: "<p>abc[]</p>",
|
|
stepFunction: async (editor) => {
|
|
splitBlock(editor);
|
|
splitBlock(editor);
|
|
},
|
|
contentAfter: "<p>abc</p><p><br></p><p>[]<br></p>",
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("Format", () => {
|
|
test("should split a paragraph before a format node", async () => {
|
|
await testEditor({
|
|
contentBefore: "<p>abc[]<b>def</b></p>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<p>abc</p><p><b>[]def</b></p>",
|
|
});
|
|
await testEditor({
|
|
// That selection is equivalent to []<b>
|
|
contentBefore: "<p>abc<b>[]def</b></p>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<p>abc</p><p><b>[]def</b></p>",
|
|
});
|
|
await testEditor({
|
|
contentBefore: "<p>abc <b>[]def</b></p>",
|
|
stepFunction: splitBlock,
|
|
// The space is converted to a non-breaking
|
|
// space so it is visible (because it's after a
|
|
// <br>).
|
|
contentAfter: "<p>abc </p><p><b>[]def</b></p>",
|
|
});
|
|
await testEditor({
|
|
contentBefore: "<p>abc<b>[] def </b></p>",
|
|
stepFunction: splitBlock,
|
|
// The space is converted to a non-breaking
|
|
// space so it is visible (because it's before a
|
|
// <br>).
|
|
// JW cAfter: '<p>abc</p><p><b>[] def</b></p>',
|
|
contentAfter: "<p>abc</p><p><b>[] def </b></p>",
|
|
});
|
|
});
|
|
|
|
test("should split a paragraph after a format node", async () => {
|
|
await testEditor({
|
|
contentBefore: "<p><b>abc</b>[]def</p>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<p><b>abc</b></p><p>[]def</p>",
|
|
});
|
|
await testEditor({
|
|
// That selection is equivalent to </b>[]
|
|
contentBefore: "<p><b>abc[]</b>def</p>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<p><b>abc</b></p><p>[]def</p>",
|
|
});
|
|
await testEditor({
|
|
contentBefore: "<p><b>abc[]</b> def</p>",
|
|
stepFunction: splitBlock,
|
|
// The space is converted to a non-breaking
|
|
// space so it is visible.
|
|
contentAfter: "<p><b>abc</b></p><p>[] def</p>",
|
|
});
|
|
await testEditor({
|
|
contentBefore: "<p><b>abc []</b>def</p>",
|
|
stepFunction: splitBlock,
|
|
// The space is converted to a non-breaking
|
|
// space so it is visible (because it's before a
|
|
// <br>).
|
|
contentAfter: "<p><b>abc </b></p><p>[]def</p>",
|
|
});
|
|
});
|
|
|
|
test("should split a paragraph at the beginning of a format node", async () => {
|
|
await testEditor({
|
|
contentBefore: "<p>[]<b>abc</b></p>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<p><br></p><p><b>[]abc</b></p>",
|
|
});
|
|
await testEditor({
|
|
// That selection is equivalent to []<b>
|
|
contentBefore: "<p><b>[]abc</b></p>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<p><br></p><p><b>[]abc</b></p>",
|
|
});
|
|
await testEditor({
|
|
contentBefore: "<p><b>[] abc</b></p>",
|
|
stepFunction: splitBlock,
|
|
// The space should have been parsed away.
|
|
// JW cAfter: '<p><br></p><p><b>[]abc</b></p>',
|
|
contentAfter: "<p><br></p><p><b>[] abc</b></p>",
|
|
});
|
|
});
|
|
|
|
test("should split a paragraph within a format node", async () => {
|
|
await testEditor({
|
|
contentBefore: "<p><b>ab[]cd</b></p>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<p><b>ab</b></p><p><b>[]cd</b></p>",
|
|
});
|
|
await testEditor({
|
|
contentBefore: "<p><b>ab []cd</b></p>",
|
|
stepFunction: splitBlock,
|
|
// The space is converted to a non-breaking
|
|
// space so it is visible.
|
|
contentAfter: "<p><b>ab </b></p><p><b>[]cd</b></p>",
|
|
});
|
|
await testEditor({
|
|
contentBefore: "<p><b>ab[] cd</b></p>",
|
|
stepFunction: splitBlock,
|
|
// The space is converted to a non-breaking
|
|
// space so it is visible.
|
|
contentAfter: "<p><b>ab</b></p><p><b>[] cd</b></p>",
|
|
});
|
|
});
|
|
|
|
test("should split a paragraph at the end of a format node", async () => {
|
|
await testEditor({
|
|
contentBefore: "<p><b>abc</b>[]</p>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<p><b>abc</b></p><p>[]<br></p>",
|
|
});
|
|
await testEditor({
|
|
// That selection is equivalent to </b>[]
|
|
contentBefore: "<p><b>abc[]</b></p>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<p><b>abc</b></p><p>[]<br></p>",
|
|
});
|
|
await testEditor({
|
|
contentBefore: "<p><b>abc[] </b></p>",
|
|
stepFunction: splitBlock,
|
|
// The space should have been parsed away.
|
|
contentAfter: "<p><b>abc</b></p><p>[]<br></p>",
|
|
});
|
|
});
|
|
|
|
async function splitBlockA(editor) {
|
|
// splitBlock in an <a> tag will open the linkPopover which will take the focus.
|
|
// So we need to put the selection back into the editor
|
|
splitBlock(editor);
|
|
editor.shared.selection.focusEditable();
|
|
await tick();
|
|
}
|
|
|
|
// @todo: re-evaluate this possibly outdated comment:
|
|
// skipping these tests cause with the link isolation the cursor can be put
|
|
// inside/outside the link so the user can choose where to insert the line break
|
|
// see `anchor.nodeName === "A" && brEls.includes(anchor.firstChild)` in line_break_plugin.js
|
|
test("should insert line breaks outside the edges of an anchor in unbreakable", async () => {
|
|
await testEditor({
|
|
contentBefore: "<div>ab<a>[]cd</a></div>",
|
|
stepFunction: splitBlockA,
|
|
contentAfter: "<div>ab<br><a>[]cd</a></div>",
|
|
});
|
|
await testEditor({
|
|
contentBefore: "<div><a>a[]b</a></div>",
|
|
stepFunction: splitBlockA,
|
|
contentAfter: "<div><a>a<br>[]b</a></div>",
|
|
});
|
|
await testEditor({
|
|
contentBefore: "<div><a>ab[]</a></div>",
|
|
stepFunction: splitBlockA,
|
|
contentAfter: "<div><a>ab</a><br><br>[]</div>",
|
|
});
|
|
await testEditor({
|
|
contentBefore: "<div><a>ab[]</a>cd</div>",
|
|
stepFunction: splitBlockA,
|
|
contentAfter: "<div><a>ab</a><br>[]cd</div>",
|
|
});
|
|
});
|
|
|
|
test("should insert a paragraph break outside the starting edge of an anchor", async () => {
|
|
await testEditor({
|
|
contentBefore: "<p><a>[]ab</a></p>",
|
|
stepFunction: splitBlockA,
|
|
contentAfterEdit:
|
|
'<p><br></p><p>\ufeff<a class="o_link_in_selection">\ufeff[]ab\ufeff</a>\ufeff</p>',
|
|
contentAfter: "<p><br></p><p><a>[]ab</a></p>",
|
|
});
|
|
await testEditor({
|
|
contentBefore: "<p>ab<a>[]cd</a></p>",
|
|
stepFunction: splitBlockA,
|
|
contentAfterEdit:
|
|
'<p>ab</p><p>\ufeff<a class="o_link_in_selection">\ufeff[]cd\ufeff</a>\ufeff</p>',
|
|
contentAfter: "<p>ab</p><p><a>[]cd</a></p>",
|
|
});
|
|
});
|
|
test("should insert a paragraph break in the middle of an anchor", async () => {
|
|
await testEditor({
|
|
contentBefore: "<p><a>a[]b</a></p>",
|
|
stepFunction: splitBlockA,
|
|
contentAfterEdit:
|
|
'<p>\ufeff<a>\ufeffa\ufeff</a>\ufeff</p><p>\ufeff<a class="o_link_in_selection">\ufeff[]b\ufeff</a>\ufeff</p>',
|
|
contentAfter: "<p><a>a</a></p><p><a>[]b</a></p>",
|
|
});
|
|
});
|
|
test("should insert a paragraph break outside the ending edge of an anchor", async () => {
|
|
await testEditor({
|
|
contentBefore: "<p><a>ab[]</a></p>",
|
|
stepFunction: async (editor) => {
|
|
splitBlock(editor);
|
|
await press("enter");
|
|
editor.shared.selection.focusEditable();
|
|
await tick();
|
|
},
|
|
contentAfterEdit: `<p>\ufeff<a href="">\ufeffab\ufeff</a>\ufeff</p><p placeholder='Type "/" for commands' class="o-we-hint">[]<br></p>`,
|
|
contentAfter: `<p><a href="">ab</a></p><p>[]<br></p>`,
|
|
});
|
|
await testEditor({
|
|
contentBefore: "<p><a>ab[]</a>cd</p>",
|
|
stepFunction: splitBlockA,
|
|
contentAfterEdit: "<p>\ufeff<a>\ufeffab\ufeff</a>\ufeff</p><p>[]cd</p>",
|
|
contentAfter: "<p><a>ab</a></p><p>[]cd</p>",
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("With attributes", () => {
|
|
test("should insert an empty paragraph before a paragraph with a span with a class", async () => {
|
|
await testEditor({
|
|
contentBefore: '<p><span class="a">ab</span></p><p><span class="b">[]cd</span></p>',
|
|
stepFunction: splitBlock,
|
|
contentAfter:
|
|
'<p><span class="a">ab</span></p><p><br></p><p><span class="b">[]cd</span></p>',
|
|
});
|
|
});
|
|
|
|
test("should split a paragraph with a span with a bold in two", async () => {
|
|
await testEditor({
|
|
contentBefore: '<p><span class="a"><b>ab[]cd</b></span></p>',
|
|
stepFunction: splitBlock,
|
|
contentAfter:
|
|
'<p><span class="a"><b>ab</b></span></p><p><span class="a"><b>[]cd</b></span></p>',
|
|
});
|
|
});
|
|
|
|
test("should split a paragraph at its end, with a paragraph after it, and both have the same class", async () => {
|
|
await testEditor({
|
|
contentBefore: '<p class="a">a[]</p><p class="a"><br></p>',
|
|
stepFunction: splitBlock,
|
|
contentAfter: '<p class="a">a</p><p class="a">[]<br></p><p class="a"><br></p>',
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("POC extra tests", () => {
|
|
test("should insert a paragraph after an empty h1", async () => {
|
|
await testEditor({
|
|
contentBefore: "<h1>[]<br></h1>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<h1><br></h1><p>[]<br></p>",
|
|
});
|
|
});
|
|
|
|
test("should insert a paragraph after an empty h1 with styles and a zero-width space", async () => {
|
|
await testEditor({
|
|
contentBefore:
|
|
'<h1><font style="color: red;" data-oe-zws-empty-inline="">[]\u200B</font><br></h1>',
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<h1><br></h1><p>[]<br></p>",
|
|
});
|
|
});
|
|
|
|
test("should insert a new paragraph after an h1 with style", async () => {
|
|
await testEditor({
|
|
contentBefore: `<h1 style="color: red">ab[]</h1>`,
|
|
stepFunction: splitBlock,
|
|
contentAfter: `<h1 style="color: red">ab</h1><p>[]<br></p>`,
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("Selection not collapsed", () => {
|
|
test("should delete the first half of a paragraph, then split it", async () => {
|
|
// Forward selection
|
|
await testEditor({
|
|
contentBefore: "<p>[ab]cd</p>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<p><br></p><p>[]cd</p>",
|
|
});
|
|
// Backward selection
|
|
await testEditor({
|
|
contentBefore: "<p>]ab[cd</p>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<p><br></p><p>[]cd</p>",
|
|
});
|
|
});
|
|
|
|
test("should delete part of a paragraph, then split it", async () => {
|
|
// Forward selection
|
|
await testEditor({
|
|
contentBefore: "<p>a[bc]d</p>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<p>a</p><p>[]d</p>",
|
|
});
|
|
// Backward selection
|
|
await testEditor({
|
|
contentBefore: "<p>a]bc[d</p>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<p>a</p><p>[]d</p>",
|
|
});
|
|
});
|
|
|
|
test("should delete the last half of a paragraph, then split it", async () => {
|
|
// Forward selection
|
|
await testEditor({
|
|
contentBefore: "<p>ab[cd]</p>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<p>ab</p><p>[]<br></p>",
|
|
});
|
|
// Backward selection
|
|
await testEditor({
|
|
contentBefore: "<p>ab]cd[</p>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<p>ab</p><p>[]<br></p>",
|
|
});
|
|
});
|
|
|
|
test("should delete all contents of a paragraph, then split it", async () => {
|
|
// Forward selection
|
|
await testEditor({
|
|
contentBefore: "<p>[abcd]</p>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<p><br></p><p>[]<br></p>",
|
|
});
|
|
// Backward selection
|
|
await testEditor({
|
|
contentBefore: "<p>]abcd[</p>",
|
|
stepFunction: splitBlock,
|
|
contentAfter: "<p><br></p><p>[]<br></p>",
|
|
});
|
|
});
|
|
|
|
test("should keep the selection at the start of the second text node after paragraph break", async () => {
|
|
await testEditor({
|
|
contentBefore: "<p>ab<br>[c]de</p>",
|
|
stepFunction: async (editor) => {
|
|
await insertText(editor, "f");
|
|
},
|
|
contentAfter: "<p>ab<br>f[]de</p>",
|
|
});
|
|
});
|
|
});
|
|
|
|
describe("Table", () => {
|
|
test("should remove all contents of an anchor td and split paragraph on forward selection", async () => {
|
|
// Forward selection
|
|
await testEditor({
|
|
contentBefore: `
|
|
<table>
|
|
<tbody>
|
|
<tr>
|
|
<td><p>[abc</p><p>def</p></td>
|
|
<td><p>abcd</p></td>
|
|
<td><p>ab]</p></td>
|
|
</tr>
|
|
<tr>
|
|
<td><p><br></p></td>
|
|
<td><p><br></p></td>
|
|
<td><p><br></p></td>
|
|
</tr>
|
|
</tbody>
|
|
</table>`,
|
|
stepFunction: splitBlock,
|
|
contentAfter: `
|
|
<table>
|
|
<tbody>
|
|
<tr>
|
|
<td><p><br></p><p>[]<br></p></td>
|
|
<td><p>abcd</p></td>
|
|
<td><p>ab</p></td>
|
|
</tr>
|
|
<tr>
|
|
<td><p><br></p></td>
|
|
<td><p><br></p></td>
|
|
<td><p><br></p></td>
|
|
</tr>
|
|
</tbody>
|
|
</table>`,
|
|
});
|
|
});
|
|
test("should remove all contents of an anchor td and split paragraph on backward selection", async () => {
|
|
// Backward selection
|
|
await testEditor({
|
|
contentBefore: `
|
|
<table>
|
|
<tbody>
|
|
<tr>
|
|
<td><p>]ab</p></td>
|
|
<td><p>abcd</p></td>
|
|
<td><p>abc</p><p>def[</p></td>
|
|
</tr>
|
|
<tr>
|
|
<td><p><br></p></td>
|
|
<td><p><br></p></td>
|
|
<td><p><br></p></td>
|
|
</tr>
|
|
</tbody>
|
|
</table>`,
|
|
stepFunction: splitBlock,
|
|
contentAfter: `
|
|
<table>
|
|
<tbody>
|
|
<tr>
|
|
<td><p>ab</p></td>
|
|
<td><p>abcd</p></td>
|
|
<td><p><br></p><p>[]<br></p></td>
|
|
</tr>
|
|
<tr>
|
|
<td><p><br></p></td>
|
|
<td><p><br></p></td>
|
|
<td><p><br></p></td>
|
|
</tr>
|
|
</tbody>
|
|
</table>`,
|
|
});
|
|
});
|
|
test("remove selected text and insert paragraph tag within a table cell and enter key is pressed", async () => {
|
|
await testEditor({
|
|
contentBefore: `
|
|
<table>
|
|
<tbody>
|
|
<tr>
|
|
<td><p>[Test</p><p>Test</p><p>Test]</p></td>
|
|
<td><p><br></p></td>
|
|
</tr>
|
|
</tbody>
|
|
</table>`,
|
|
stepFunction: splitBlock,
|
|
contentAfter: `
|
|
<table>
|
|
<tbody>
|
|
<tr>
|
|
<td><p><br></p><p>[]<br></p></td>
|
|
<td><p><br></p></td>
|
|
</tr>
|
|
</tbody>
|
|
</table>`,
|
|
});
|
|
});
|
|
});
|