mirror of
https://github.com/vector-im/element-web.git
synced 2024-11-25 01:48:43 +08:00
f0ee7f7905
Merge remote-tracking branch 'repomerge/t3chguy/repomerge' into t3chguy/repo-merge Signed-off-by: Michael Telatynski <7t3chguy@gmail.com>
488 lines
22 KiB
TypeScript
488 lines
22 KiB
TypeScript
/*
|
|
Copyright 2024 New Vector Ltd.
|
|
Copyright 2020 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.
|
|
*/
|
|
|
|
import EditorModel from "../../../src/editor/model";
|
|
import { createPartCreator, createRenderer } from "./mock";
|
|
import {
|
|
formatRange,
|
|
formatRangeAsCode,
|
|
formatRangeAsLink,
|
|
selectRangeOfWordAtCaret,
|
|
toggleInlineFormat,
|
|
} from "../../../src/editor/operations";
|
|
import { Formatting } from "../../../src/components/views/rooms/MessageComposerFormatBar";
|
|
import { longestBacktickSequence } from "../../../src/editor/deserialize";
|
|
import DocumentPosition from "../../../src/editor/position";
|
|
|
|
const SERIALIZED_NEWLINE = { text: "\n", type: "newline" };
|
|
|
|
describe("editor/operations: formatting operations", () => {
|
|
const renderer = createRenderer();
|
|
const pc = createPartCreator();
|
|
|
|
describe("formatRange", () => {
|
|
it.each([[Formatting.Bold, "hello **world**!"]])(
|
|
"should correctly wrap format %s",
|
|
(formatting: Formatting, expected: string) => {
|
|
const model = new EditorModel([pc.plain("hello world!")], pc, renderer);
|
|
|
|
const range = model.startRange(model.positionForOffset(6, false), model.positionForOffset(11, false)); // around "world"
|
|
|
|
expect(range.parts[0].text).toBe("world");
|
|
expect(model.serializeParts()).toEqual([{ text: "hello world!", type: "plain" }]);
|
|
formatRange(range, formatting);
|
|
expect(model.serializeParts()).toEqual([{ text: expected, type: "plain" }]);
|
|
},
|
|
);
|
|
|
|
it("should apply to word range is within if length 0", () => {
|
|
const model = new EditorModel([pc.plain("hello world!")], pc, renderer);
|
|
|
|
const range = model.startRange(model.positionForOffset(6, false));
|
|
|
|
expect(model.serializeParts()).toEqual([{ text: "hello world!", type: "plain" }]);
|
|
formatRange(range, Formatting.Bold);
|
|
expect(model.serializeParts()).toEqual([{ text: "hello **world!**", type: "plain" }]);
|
|
});
|
|
|
|
it("should do nothing for a range with length 0 at initialisation", () => {
|
|
const model = new EditorModel([pc.plain("hello world!")], pc, renderer);
|
|
|
|
const range = model.startRange(model.positionForOffset(6, false));
|
|
range.setWasEmpty(false);
|
|
|
|
expect(model.serializeParts()).toEqual([{ text: "hello world!", type: "plain" }]);
|
|
formatRange(range, Formatting.Bold);
|
|
expect(model.serializeParts()).toEqual([{ text: "hello world!", type: "plain" }]);
|
|
});
|
|
});
|
|
|
|
describe("formatRangeAsLink", () => {
|
|
it.each([
|
|
// Caret is denoted by | in the expectation string
|
|
["testing", "[testing](|)", ""],
|
|
["testing", "[testing](foobar|)", "foobar"],
|
|
["[testing]()", "testing|", ""],
|
|
["[testing](foobar)", "testing|", ""],
|
|
])("converts %s -> %s", (input: string, expectation: string, text: string) => {
|
|
const model = new EditorModel([pc.plain(`foo ${input} bar`)], pc, renderer);
|
|
|
|
const range = model.startRange(
|
|
model.positionForOffset(4, false),
|
|
model.positionForOffset(4 + input.length, false),
|
|
); // around input
|
|
|
|
expect(range.parts[0].text).toBe(input);
|
|
formatRangeAsLink(range, text);
|
|
expect((renderer.caret as DocumentPosition).offset).toBe(4 + expectation.indexOf("|"));
|
|
expect(model.parts[0].text).toBe("foo " + expectation.replace("|", "") + " bar");
|
|
});
|
|
});
|
|
|
|
describe("toggleInlineFormat", () => {
|
|
it("works for words", () => {
|
|
const model = new EditorModel([pc.plain("hello world!")], pc, renderer);
|
|
|
|
const range = model.startRange(model.positionForOffset(6, false), model.positionForOffset(11, false)); // around "world"
|
|
|
|
expect(range.parts[0].text).toBe("world");
|
|
expect(model.serializeParts()).toEqual([{ text: "hello world!", type: "plain" }]);
|
|
formatRange(range, Formatting.Italics);
|
|
expect(model.serializeParts()).toEqual([{ text: "hello *world*!", type: "plain" }]);
|
|
});
|
|
|
|
describe("escape backticks", () => {
|
|
it("works for escaping backticks in between texts", () => {
|
|
const renderer = createRenderer();
|
|
const pc = createPartCreator();
|
|
const model = new EditorModel([pc.plain("hello ` world!")], pc, renderer);
|
|
|
|
const range = model.startRange(model.positionForOffset(0, false), model.positionForOffset(13, false)); // hello ` world
|
|
|
|
expect(range.parts[0].text.trim().includes("`")).toBeTruthy();
|
|
expect(longestBacktickSequence(range.parts[0].text.trim())).toBe(1);
|
|
expect(model.serializeParts()).toEqual([{ text: "hello ` world!", type: "plain" }]);
|
|
formatRangeAsCode(range);
|
|
expect(model.serializeParts()).toEqual([{ text: "``hello ` world``!", type: "plain" }]);
|
|
});
|
|
|
|
it("escapes longer backticks in between text", () => {
|
|
const renderer = createRenderer();
|
|
const pc = createPartCreator();
|
|
const model = new EditorModel([pc.plain("hello```world")], pc, renderer);
|
|
|
|
const range = model.startRange(model.positionForOffset(0, false), model.getPositionAtEnd()); // hello```world
|
|
|
|
expect(range.parts[0].text.includes("`")).toBeTruthy();
|
|
expect(longestBacktickSequence(range.parts[0].text)).toBe(3);
|
|
expect(model.serializeParts()).toEqual([{ text: "hello```world", type: "plain" }]);
|
|
formatRangeAsCode(range);
|
|
expect(model.serializeParts()).toEqual([{ text: "````hello```world````", type: "plain" }]);
|
|
});
|
|
|
|
it("escapes non-consecutive with varying length backticks in between text", () => {
|
|
const renderer = createRenderer();
|
|
const pc = createPartCreator();
|
|
const model = new EditorModel([pc.plain("hell```o`w`o``rld")], pc, renderer);
|
|
|
|
const range = model.startRange(model.positionForOffset(0, false), model.getPositionAtEnd()); // hell```o`w`o``rld
|
|
expect(range.parts[0].text.includes("`")).toBeTruthy();
|
|
expect(longestBacktickSequence(range.parts[0].text)).toBe(3);
|
|
expect(model.serializeParts()).toEqual([{ text: "hell```o`w`o``rld", type: "plain" }]);
|
|
formatRangeAsCode(range);
|
|
expect(model.serializeParts()).toEqual([{ text: "````hell```o`w`o``rld````", type: "plain" }]);
|
|
});
|
|
|
|
it("untoggles correctly if its already formatted", () => {
|
|
const renderer = createRenderer();
|
|
const pc = createPartCreator();
|
|
const model = new EditorModel([pc.plain("```hello``world```")], pc, renderer);
|
|
|
|
const range = model.startRange(model.positionForOffset(0, false), model.getPositionAtEnd()); // hello``world
|
|
expect(range.parts[0].text.includes("`")).toBeTruthy();
|
|
expect(longestBacktickSequence(range.parts[0].text)).toBe(3);
|
|
expect(model.serializeParts()).toEqual([{ text: "```hello``world```", type: "plain" }]);
|
|
formatRangeAsCode(range);
|
|
expect(model.serializeParts()).toEqual([{ text: "hello``world", type: "plain" }]);
|
|
});
|
|
it("untoggles correctly it contains varying length of backticks between text", () => {
|
|
const renderer = createRenderer();
|
|
const pc = createPartCreator();
|
|
const model = new EditorModel([pc.plain("````hell```o`w`o``rld````")], pc, renderer);
|
|
|
|
const range = model.startRange(model.positionForOffset(0, false), model.getPositionAtEnd()); // hell```o`w`o``rld
|
|
expect(range.parts[0].text.includes("`")).toBeTruthy();
|
|
expect(longestBacktickSequence(range.parts[0].text)).toBe(4);
|
|
expect(model.serializeParts()).toEqual([{ text: "````hell```o`w`o``rld````", type: "plain" }]);
|
|
formatRangeAsCode(range);
|
|
expect(model.serializeParts()).toEqual([{ text: "hell```o`w`o``rld", type: "plain" }]);
|
|
});
|
|
});
|
|
|
|
it("works for parts of words", () => {
|
|
const renderer = createRenderer();
|
|
const pc = createPartCreator();
|
|
const model = new EditorModel([pc.plain("hello world!")], pc, renderer);
|
|
|
|
const range = model.startRange(model.positionForOffset(7, false), model.positionForOffset(10, false)); // around "orl"
|
|
|
|
expect(range.parts[0].text).toBe("orl");
|
|
expect(model.serializeParts()).toEqual([{ text: "hello world!", type: "plain" }]);
|
|
toggleInlineFormat(range, "*");
|
|
expect(model.serializeParts()).toEqual([{ text: "hello w*orl*d!", type: "plain" }]);
|
|
});
|
|
|
|
it("works for around pills", () => {
|
|
const renderer = createRenderer();
|
|
const pc = createPartCreator();
|
|
const model = new EditorModel(
|
|
[pc.plain("hello there "), pc.atRoomPill("@room"), pc.plain(", how are you doing?")],
|
|
pc,
|
|
renderer,
|
|
);
|
|
|
|
const range = model.startRange(model.positionForOffset(6, false), model.positionForOffset(30, false)); // around "there @room, how are you"
|
|
|
|
expect(range.parts.map((p) => p.text).join("")).toBe("there @room, how are you");
|
|
expect(model.serializeParts()).toEqual([
|
|
{ text: "hello there ", type: "plain" },
|
|
{ text: "@room", type: "at-room-pill" },
|
|
{ text: ", how are you doing?", type: "plain" },
|
|
]);
|
|
formatRange(range, Formatting.Italics);
|
|
expect(model.serializeParts()).toEqual([
|
|
{ text: "hello *there ", type: "plain" },
|
|
{ text: "@room", type: "at-room-pill" },
|
|
{ text: ", how are you* doing?", type: "plain" },
|
|
]);
|
|
});
|
|
|
|
it("works for a paragraph", () => {
|
|
const renderer = createRenderer();
|
|
const pc = createPartCreator();
|
|
const model = new EditorModel(
|
|
[pc.plain("hello world,"), pc.newline(), pc.plain("how are you doing?")],
|
|
pc,
|
|
renderer,
|
|
);
|
|
|
|
const range = model.startRange(model.positionForOffset(6, false), model.positionForOffset(16, false)); // around "world,\nhow"
|
|
|
|
expect(range.parts.map((p) => p.text).join("")).toBe("world,\nhow");
|
|
expect(model.serializeParts()).toEqual([
|
|
{ text: "hello world,", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
{ text: "how are you doing?", type: "plain" },
|
|
]);
|
|
formatRange(range, Formatting.Bold);
|
|
expect(model.serializeParts()).toEqual([
|
|
{ text: "hello **world,", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
{ text: "how** are you doing?", type: "plain" },
|
|
]);
|
|
});
|
|
|
|
it("works for a paragraph with spurious breaks around it in selected range", () => {
|
|
const renderer = createRenderer();
|
|
const pc = createPartCreator();
|
|
const model = new EditorModel(
|
|
[
|
|
pc.newline(),
|
|
pc.newline(),
|
|
pc.plain("hello world,"),
|
|
pc.newline(),
|
|
pc.plain("how are you doing?"),
|
|
pc.newline(),
|
|
pc.newline(),
|
|
],
|
|
pc,
|
|
renderer,
|
|
);
|
|
|
|
const range = model.startRange(model.positionForOffset(0, false), model.getPositionAtEnd()); // select-all
|
|
|
|
expect(range.parts.map((p) => p.text).join("")).toBe("\n\nhello world,\nhow are you doing?\n\n");
|
|
expect(model.serializeParts()).toEqual([
|
|
SERIALIZED_NEWLINE,
|
|
SERIALIZED_NEWLINE,
|
|
{ text: "hello world,", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
{ text: "how are you doing?", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
SERIALIZED_NEWLINE,
|
|
]);
|
|
formatRange(range, Formatting.Bold);
|
|
expect(model.serializeParts()).toEqual([
|
|
SERIALIZED_NEWLINE,
|
|
SERIALIZED_NEWLINE,
|
|
{ text: "**hello world,", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
{ text: "how are you doing?**", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
SERIALIZED_NEWLINE,
|
|
]);
|
|
});
|
|
|
|
it("works for multiple paragraph", () => {
|
|
const renderer = createRenderer();
|
|
const pc = createPartCreator();
|
|
const model = new EditorModel(
|
|
[
|
|
pc.plain("hello world,"),
|
|
pc.newline(),
|
|
pc.plain("how are you doing?"),
|
|
pc.newline(),
|
|
pc.newline(),
|
|
pc.plain("new paragraph"),
|
|
],
|
|
pc,
|
|
renderer,
|
|
);
|
|
|
|
let range = model.startRange(model.positionForOffset(0, true), model.getPositionAtEnd()); // select-all
|
|
|
|
expect(model.serializeParts()).toEqual([
|
|
{ text: "hello world,", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
{ text: "how are you doing?", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
SERIALIZED_NEWLINE,
|
|
{ text: "new paragraph", type: "plain" },
|
|
]);
|
|
toggleInlineFormat(range, "__");
|
|
expect(model.serializeParts()).toEqual([
|
|
{ text: "__hello world,", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
{ text: "how are you doing?__", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
SERIALIZED_NEWLINE,
|
|
{ text: "__new paragraph__", type: "plain" },
|
|
]);
|
|
range = model.startRange(model.positionForOffset(0, true), model.getPositionAtEnd()); // select-all
|
|
toggleInlineFormat(range, "__");
|
|
expect(model.serializeParts()).toEqual([
|
|
{ text: "hello world,", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
{ text: "how are you doing?", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
SERIALIZED_NEWLINE,
|
|
{ text: "new paragraph", type: "plain" },
|
|
]);
|
|
});
|
|
|
|
it("format word at caret position at beginning of new line without previous selection", () => {
|
|
const renderer = createRenderer();
|
|
const pc = createPartCreator();
|
|
const model = new EditorModel([pc.newline(), pc.plain("hello!")], pc, renderer);
|
|
|
|
let range = model.startRange(model.positionForOffset(1, false));
|
|
|
|
// Initial position should equal start and end since we did not select anything
|
|
expect(range.getLastStartingPosition()).toBe(range.start);
|
|
expect(range.getLastStartingPosition()).toBe(range.end);
|
|
|
|
formatRange(range, Formatting.Bold); // Toggle
|
|
|
|
expect(model.serializeParts()).toEqual([SERIALIZED_NEWLINE, { text: "**hello!**", type: "plain" }]);
|
|
|
|
formatRange(range, Formatting.Bold); // Untoggle
|
|
|
|
expect(model.serializeParts()).toEqual([SERIALIZED_NEWLINE, { text: "hello!", type: "plain" }]);
|
|
|
|
// Check if it also works for code as it uses toggleInlineFormatting only indirectly
|
|
range = model.startRange(model.positionForOffset(1, false));
|
|
selectRangeOfWordAtCaret(range);
|
|
|
|
formatRange(range, Formatting.Code); // Toggle
|
|
|
|
expect(model.serializeParts()).toEqual([SERIALIZED_NEWLINE, { text: "`hello!`", type: "plain" }]);
|
|
|
|
formatRange(range, Formatting.Code); // Untoggle
|
|
expect(model.serializeParts()).toEqual([SERIALIZED_NEWLINE, { text: "hello!", type: "plain" }]);
|
|
});
|
|
|
|
it("caret resets correctly to current line when untoggling formatting while caret at line end", () => {
|
|
const renderer = createRenderer();
|
|
const pc = createPartCreator();
|
|
const model = new EditorModel(
|
|
[pc.plain("hello **hello!**"), pc.newline(), pc.plain("world")],
|
|
pc,
|
|
renderer,
|
|
);
|
|
|
|
expect(model.serializeParts()).toEqual([
|
|
{ text: "hello **hello!**", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
{ text: "world", type: "plain" },
|
|
]);
|
|
|
|
const endOfFirstLine = 16;
|
|
const range = model.startRange(model.positionForOffset(endOfFirstLine, true));
|
|
|
|
formatRange(range, Formatting.Bold); // Untoggle
|
|
formatRange(range, Formatting.Italics); // Toggle
|
|
|
|
// We expect formatting to still happen in the first line as the caret should not jump down
|
|
expect(model.serializeParts()).toEqual([
|
|
{ text: "hello *hello!*", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
{ text: "world", type: "plain" },
|
|
]);
|
|
});
|
|
|
|
it("format link in front of new line part", () => {
|
|
const renderer = createRenderer();
|
|
const pc = createPartCreator();
|
|
const model = new EditorModel(
|
|
[pc.plain("hello!"), pc.newline(), pc.plain("world!"), pc.newline()],
|
|
pc,
|
|
renderer,
|
|
);
|
|
|
|
let range = model.startRange(model.getPositionAtEnd().asOffset(model).add(-1).asPosition(model)); // select-all
|
|
|
|
expect(model.serializeParts()).toEqual([
|
|
{ text: "hello!", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
{ text: "world!", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
]);
|
|
|
|
formatRange(range, Formatting.InsertLink); // Toggle
|
|
expect(model.serializeParts()).toEqual([
|
|
{ text: "hello!", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
{ text: "[world!]()", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
]);
|
|
|
|
range = model.startRange(model.getPositionAtEnd().asOffset(model).add(-1).asPosition(model)); // select-all
|
|
formatRange(range, Formatting.InsertLink); // Untoggle
|
|
expect(model.serializeParts()).toEqual([
|
|
{ text: "hello!", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
{ text: "world!", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
]);
|
|
});
|
|
|
|
it("format multi line code", () => {
|
|
const renderer = createRenderer();
|
|
const pc = createPartCreator();
|
|
const model = new EditorModel(
|
|
[pc.plain("int x = 1;"), pc.newline(), pc.newline(), pc.plain("int y = 42;")],
|
|
pc,
|
|
renderer,
|
|
);
|
|
|
|
let range = model.startRange(model.positionForOffset(0), model.getPositionAtEnd()); // select-all
|
|
|
|
expect(range.parts.map((p) => p.text).join("")).toBe("int x = 1;\n\nint y = 42;");
|
|
|
|
expect(model.serializeParts()).toEqual([
|
|
{ text: "int x = 1;", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
SERIALIZED_NEWLINE,
|
|
{ text: "int y = 42;", type: "plain" },
|
|
]);
|
|
|
|
formatRange(range, Formatting.Code); // Toggle
|
|
|
|
expect(model.serializeParts()).toEqual([
|
|
{ text: "```", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
{ text: "int x = 1;", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
SERIALIZED_NEWLINE,
|
|
{ text: "int y = 42;", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
{ text: "```", type: "plain" },
|
|
]);
|
|
|
|
range = model.startRange(model.positionForOffset(0, false), model.getPositionAtEnd()); // select-all
|
|
formatRange(range, Formatting.Code); // Untoggle
|
|
|
|
expect(model.serializeParts()).toEqual([
|
|
{ text: "int x = 1;", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
SERIALIZED_NEWLINE,
|
|
{ text: "int y = 42;", type: "plain" },
|
|
]);
|
|
});
|
|
|
|
it("does not format pure white space", () => {
|
|
const renderer = createRenderer();
|
|
const pc = createPartCreator();
|
|
const model = new EditorModel(
|
|
[pc.plain(" "), pc.newline(), pc.newline(), pc.plain(" ")],
|
|
pc,
|
|
renderer,
|
|
);
|
|
|
|
const range = model.startRange(model.positionForOffset(0), model.getPositionAtEnd()); // select-all
|
|
expect(range.parts.map((p) => p.text).join("")).toBe(" \n\n ");
|
|
|
|
expect(model.serializeParts()).toEqual([
|
|
{ text: " ", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
SERIALIZED_NEWLINE,
|
|
{ text: " ", type: "plain" },
|
|
]);
|
|
|
|
formatRange(range, Formatting.Bold);
|
|
|
|
expect(model.serializeParts()).toEqual([
|
|
{ text: " ", type: "plain" },
|
|
SERIALIZED_NEWLINE,
|
|
SERIALIZED_NEWLINE,
|
|
{ text: " ", type: "plain" },
|
|
]);
|
|
});
|
|
});
|
|
});
|