mirror of
https://github.com/element-hq/element-web
synced 2024-11-27 19:56:47 +03:00
533 lines
23 KiB
TypeScript
533 lines
23 KiB
TypeScript
/*
|
|
Copyright 2020 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.
|
|
*/
|
|
|
|
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';
|
|
|
|
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.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" },
|
|
]);
|
|
});
|
|
});
|
|
});
|