@brandup/ui-richeditor 1.0.43 → 1.0.45

package/README.md

@@ -49,7 +49,8 @@ editor.onChange(({ value }) => console.log(value));
 | `placeholder` | `string \| null` | Текст-заглушка |
 | `multiline` | `boolean` | Многострочный режим |
 | `paragraph` | `"block" \| "break"` | Что делает Enter: новый абзац (по умолчанию) или мягкий перенос |
-| `blocks` | `BlockType[]` | Типы блоков многострочного режима: `quote`, `code` (по умолчанию только `paragraph`) |
+| `blocks` | `BlockType[]` | Типы блоков многострочного режима: `quote`, `code` (по умолчанию все); пустой список оставляет только `paragraph` |
+| `keepFocus` | `boolean` | Держать ли фокус в поле, пока открыта панель смайликов (по умолчанию да, а на сенсорном устройстве нет) |
 | `readonly` | `boolean` | Только для чтения — запрещает ввод и изменение текста (выделение и копирование остаются) |
 | `toolbarContainer` | `HTMLElement \| null` | Контейнер для панели; по умолчанию `document.body` (`position: fixed`). Если задан — панель монтируется в него и позиционируется над ним (`position: absolute`). Контейнер должен быть `position: relative` |
 | `value` | `string` | Начальное значение |
@@ -70,7 +71,8 @@ editor.onChange(({ value }) => console.log(value));
 | `setValue(value: string): void` | Установить значение (нормализует, генерирует `change`) |
 | `flushChange(): void` | Доставить отложенное `change` немедленно (см. ниже) |
 | `getLength(): number` | Длина текста (без учёта переводов строк) |
-| `focus(): void` | Установить фокус |
+| `focus(atEnd?): void` | Установить фокус; каретку не двигает, а при `atEnd` ставит её в конец, если её ещё не было |
+| `releaseFocus(): void` | Отпустить фокус, запомнив каретку — на время своего окна |
 | `applyFormat(tool): void` | Переключить формат на выделении (слово целиком) |
 | `applyBlock(type): void` | Переключить тип блоков под выделением; повторное применение возвращает обычный текст |
 | `applyCode(): void` | Код по выделению: моноширинный для части строки, блок — для целых строк |
@@ -86,12 +88,19 @@ editor.onChange(({ value }) => console.log(value));
 | `canUndo`, `canRedo` | Доступность отмены/повтора |
 | `applyAction(action): void` | Выполнить действие панели (`erase`/`undo`/`redo`) |
 | `isActionEnabled(action): boolean` | Доступно ли действие сейчас |
-| `insertText(text): void` | Вставить текст в каретку (или вместо выделения) с учётом режима набора |
+| `insertText(text): void` | Вставить текст в каретку (или вместо выделения) с учётом режима набора; без фокуса вставляет по снятой каретке |
+| `openEmojiPicker(initiator, container?): void` | Открыть панель смайликов у кнопки; повторный вызов у той же кнопки её закрывает |
 | `selection: Selection \| null` | Выделение, если оно внутри редактора (иначе `null`) — единая точка доступа для хоста |
 | `selectNode(node): void` | Выделить узел внутри редактора: следующая вставка заменит его целиком |
 | `onChange(handler)` | Подписка на событие `richeditor-change` |
 | `destroy(): void` | Разворачивает элемент обратно и освобождает ресурсы |
 
+### Фокус на время своего слоя
+
+Окно хоста (модальное) забирает фокус всегда: правка идёт в нём, а мигающая под ним каретка только сбивает с толку. Панель смайликов — наоборот, слой над полем: каретка на виду, и видно, куда встанет символ. На сенсорном устройстве фокус вместо этого поднимает экранную клавиатуру, которая саму панель и закрывает, — там его отпускают и для неё (`keepFocus`).
+
+Каретка при этом не теряется: она снимается текстовыми смещениями, `insertText()` возвращает её сам (вставка из панели идёт без фокуса), а `focus()` — вместе с фокусом. Правку на это время придерживает вызывающий: снятие фокуса не конец ввода, и нормализация обрезала бы пробел у каретки.
+
 ## Событие изменения
 
 `getValue()` считает значение по DOM и точен всегда. А вот **уведомление** `richeditor-change` при печати доставляется с задержкой: сериализация — самая дорогая операция редактора (обход всего содержимого), а печать даёт `input` на каждый символ.
@@ -135,13 +144,15 @@ new RichEditor(elem, { format: true, actions: ["emoji", "erase", "undo", "redo"]
 | `undo` | Отменить | `undo()` | история пуста |
 | `redo` | Повторить | `redo()` | нечего повторять |
 
-Кнопки действий (`.action-button`) отделены от кнопок форматирования (`.format-button`) разделителем `.split` и получают атрибут `disabled`, когда действие недоступно. Панель показывается и в том случае, если инструментов форматирования нет, а действия заданы.
+Кнопки действий (`.action-button`) стоят в одном ряду с инструментами (`.format-button`) и блоками (`.block-button`) — всё это правка оформления — и получают атрибут `disabled`, когда действие недоступно. Разделитель `.split` отбивает только кнопки хоста: они про другое. Панель показывается и в том случае, если инструментов форматирования нет, а действия заданы.
 
 ### Панель смайликов
 
 Кнопка `emoji` открывает под панелью попап `.ui-richeditor-emoji` со списком символов (`EMOJIS` — экспортируется пакетом). Выбранный символ вставляется через `insertText()`, то есть в текущую каретку и с учётом ожидающих форматов режима набора; попап после выбора закрывается.
 
-Открытием и закрытием управляет `PopupManager` из [`@brandup/ui-kit`](../brandup-ui-kit) — оттуда же приходят базовые стили `.ui-popup`. Ни кнопка, ни попап не забирают фокус у редактора (`mousedown` гасится), поэтому каретка и выделение сохраняются. Список кнопок собирается лениво, при первом открытии.
+Открытием и закрытием управляет `PopupManager` из [`@brandup/ui-kit`](../brandup-ui-kit) — оттуда же приходят базовые стили `.ui-popup`. Ни кнопка, ни попап не забирают фокус сами (`mousedown` гасится), поэтому каретка и выделение сохраняются; на сенсорном устройстве поле отдаёт фокус намеренно (см. «Фокус на время своего слоя»), и вставка идёт по снятой каретке. Список кнопок собирается лениво, при первом открытии.
+
+Панель — слой редактора, поэтому открывает её он сам (`openEmojiPicker()`): на время её работы он придерживает правку, чтобы нормализация не обрезала пробел у каретки. Хост может открыть её у своей кнопки, передав вторым аргументом контейнер, — так делает [`@brandup/ui-messageeditor`](../brandup-ui-messageeditor).
 
 ## Многострочный режим: абзацы и переносы
 
@@ -155,16 +166,18 @@ new RichEditor(elem, { format: true, actions: ["emoji", "erase", "undo", "redo"]
 
 В этом режиме абзацных блоков в содержимом нет вовсе: значение загружается плоским текстом, где каждый `\n` становится `<br>` внутри единственного `<p>`. Иначе два переноса рисовались бы двумя абзацами, а у хоста без отступов между ними это неотличимо от одного переноса — значение расходилось бы с видимым текстом.
 
-Хвостовой перенос абзаца отбрасывается (это `<br>`-заполнитель); пустая строка делается отдельным абзацем.
+Хвостовой перенос отбрасывается ровно один — это `<br>`-заполнитель, без которого не видна последняя строка. Набранные пустые строки сохраняются и в поле, и в значении, где бы они ни стояли — в начале блока, в середине или в конце.
 
-При нормализации (потеря фокуса, `setValue`, инициализация) пустые абзацы удаляются.
+Блоки в этом режиме появляются побочно — правкой блочного типа, — поэтому нормализация сводит соседние абзацы обратно в один: их граница уходила бы в значение пустой строкой, которой на экране нет.
+
+При нормализации (потеря фокуса, `setValue`, инициализация) пустые абзацы удаляются — кроме одного: пустой абзац сразу за блоком другого типа остаётся. Это единственное место, где каретка стоит вне цитаты или кода, и без него правка запиралась бы в блоке. В значение такой абзац не попадает — хвост значения обрезается.
 
 ## Блоки: цитата и код
 
-Кроме абзаца многострочный режим знает и другие типы блоков верхнего уровня. Они подключаются **явно** — их понимает не каждый получатель:
+Кроме абзаца многострочный режим знает и другие типы блоков верхнего уровня — цитату и блок кода. Доступны они по умолчанию; поле, где они ни к чему, ограничивают пустым списком:
 
 ```typescript
-new RichEditor(elem, { format: true, multiline: true, blocks: ["quote", "code"] });
+new RichEditor(elem, { format: true, multiline: true, blocks: [] }); // только обычный текст
 ```
 
 | Тип | Тег | Разметка | Enter внутри |
@@ -175,7 +188,7 @@ new RichEditor(elem, { format: true, multiline: true, blocks: ["quote", "code"]
 
 Обычный текст — такой же тип, а не «тип не задан»: он есть в наборе всегда, им становится содержимое, не попавшее ни в какой блок, и в него же блок возвращают. Кнопки в панели (`.block-button`) получают только остальные типы.
 
-Кнопки кода (моноширинного и блока) и спойлера временно скрыты (`HIDDEN_TOOLS`/`HIDDEN_BLOCKS` в `./toolbar`): сами возможности работают — значение разбирается, показывается и сохраняется, правку можно вызвать из кода (`applyFormat`, `applyBlock`, `applyCode`), — но в панель они пока не выводятся.
+Кнопка спойлера временно скрыта (`HIDDEN_TOOLS` в `./toolbar`): сам инструмент работает — значение разбирается, показывается и сохраняется, правку можно вызвать из кода (`applyFormat`), — но в панель он пока не выводится.
 
 ### Одна кнопка на моноширинный и блок кода
 
@@ -188,6 +201,8 @@ new RichEditor(elem, { format: true, multiline: true, blocks: ["quote", "code"]
 
 Тем же занимается `applyCode()`, а `isCodeActive()` отвечает, включён ли код в любом виде — им подсвечена кнопка.
 
+Перенос строки в моноширинном тоже не живёт: значение берёт оттуда голый текст, и строка пропала бы — поле показывало бы две, а получатель увидел одну. Поэтому Enter разрезает моноширинный: форматирование продолжается на новой строке, только если там что-то осталось.
+
 В коде разметки нет — ни в моноширинном, ни в блоке: значение берёт оттуда голый текст, и любое форматирование внутри до получателя не доедет. Поэтому при переходе в моноширинный прежнее форматирование с этого куска снимается, внутри кода остальные инструменты недоступны (`isToolEnabled()` — кнопки гаснут), а разметка, попавшая внутрь как-то ещё (вставка, чужое значение), вычищается при первой же нормализации. Если включено только что-то одно, кнопка остаётся обычной: инструмента (`.format-button`) или блока (`.block-button`).
 
 Переключение:
@@ -198,7 +213,7 @@ new RichEditor(elem, { format: true, multiline: true, blocks: ["quote", "code"]
 
 Особенности блока кода: инлайновое форматирование внутри не размечается (написанное остаётся буквальным) и снимается при переключении в этот тип, а пробелы внутри не схлопываются — отступы там часть текста.
 
-Подряд идущие строки с маркером цитаты — одна цитата; пустая строка между ними разделяет цитаты. Незакрытое ограждение блоком не считается: его строки остаются текстом, иначе одна случайная кавычка съедала бы весь остаток сообщения. Блок отключённого типа, пришедший вставкой или из значения, сохраняется как обычный текст — разметки от него в значении не будет, но текст не теряется.
+Подряд идущие строки с маркером цитаты — одна цитата; пустая строка между ними разделяет цитаты. В режиме мягких переносов пустой строки между блоками нет, поэтому соседние цитаты там склеиваются в одну сразу в поле — иначе оно показывало бы два блока, а в значении и у получателя был бы один. Незакрытое ограждение блоком не считается: его строки остаются текстом, иначе одна случайная кавычка съедала бы весь остаток сообщения. Блок отключённого типа, пришедший вставкой или из значения, сохраняется как обычный текст — разметки от него в значении не будет, но текст не теряется.
 
 В режиме `paragraph: "break"` блоки работают так же, но пустая строка их не разделяет — там она сама по себе строка сообщения. Блок узнаётся по собственной разметке, поэтому между обычным текстом и цитатой в значении стоит один перенос, а не два.
 
@@ -227,6 +242,10 @@ new RichEditor(elem, { format: true, multiline: true, blocks: ["quote", "code"]
 
 Без форматирования (plain) значение хранится как markdown без инструментов: абзацы `\n\n`, мягкий перенос `\n`.
 
+Маркер того же инструмента из чужого диалекта разбирается наравне со своим: `*жирный*` — родная разметка WhatsApp, и так размечены сообщения, набранные до редактора. Показывать их звёздочками значит показывать не то, что увидит получатель.
+
+Переписывать под свой маркер при этом нельзя — открыть и закрыть сообщение меняло бы текст, — поэтому редактор запоминает, чем текст был размечен, и возвращает в значение то же самое. Настроенный маркер ставится только на то, что отформатировали в поле. Настройка меняет их местами: заданный `markers.bold = "*"` делает чужим диалектом уже `**`.
+
 Маркеры markdown настраиваются через `markers`. При разборе применяются по убыванию длины, поэтому длинный маркер срабатывает раньше короткого-префикса. Глубоко вложенные комбинации гарантированно сохраняются только в режиме `html`.
 
 Вложенные пары разбираются (`_а **б** в_`), а вот **пересекающиеся** остаются текстом: в `**а _б** в_` внутренняя пара пересекает внешнюю, разметкой такое невыразимо, и короткий маркер отбрасывается — как и в мессенджерах.

package/package.json

@@ -27,12 +27,12 @@
     "email": "it@brandup.online"
   },
   "license": "Apache-2.0",
-  "version": "1.0.43",
+  "version": "1.0.45",
   "main": "source/index.ts",
   "types": "source/index.ts",
   "dependencies": {
-    "@brandup/ui": "^2.0.7",
-    "@brandup/ui-kit": "^1.0.43"
+    "@brandup/ui": "^2.0.9",
+    "@brandup/ui-kit": "^1.0.45"
   },
   "files": [
     "source",

package/source/editing.ts

@@ -4,13 +4,9 @@
 
 import { deserialize } from "./serialize";
 import { blockAt, blockTypeOf, blocksInRange, createBlock, isBlock } from "./paragraphs";
-import { documentSelection, innerSelection } from "./selection";
+import { documentSelection, innerSelection, literalAncestor } from "./selection";
 import { BLOCK_TYPES, DEFAULT_BLOCK, type BlockType, type FormatMarkers, type FormatTool } from "./format-config";
 
-function emptyParagraph(): HTMLParagraphElement {
-	return createBlock(DEFAULT_BLOCK) as HTMLParagraphElement;
-}
-
 // убирает пустые текст-узлы и ставит <br>-заполнитель в пустой абзац (для видимости и каретки)
 function fillEmptyParagraph(p: HTMLElement) {
 	p.normalize(); // удаляет пустые Text-узлы, склеивает соседние
@@ -172,6 +168,11 @@ export function atBlockStart(editable: HTMLElement, range: Range): boolean {
 	const block = blockAt(editable, range.startContainer);
 	if (!block) return false;
 
+	// В пустом блоке каретка всегда в его начале: <br> там — заполнитель, он делает строку
+	// видимой, но строкой не является. Иначе из опустевшей цитаты было бы не выйти — каретка
+	// стоит за заполнителем, и проверка ниже приняла бы его за конец первой строки.
+	if (!(block.textContent ?? "").length) return true;
+
 	const before = document.createRange();
 	before.selectNodeContents(block);
 	before.setEnd(range.startContainer, range.startOffset);
@@ -183,6 +184,35 @@ export function atBlockStart(editable: HTMLElement, range: Range): boolean {
 	return before.toString().length === 0;
 }
 
+/**
+ * Block the caret sits in, or null when it stands at the editor level — an empty editor, or text
+ * that has not been wrapped into a paragraph yet.
+ */
+function blockOf(editable: HTMLElement, node: Node): HTMLElement | null {
+	let current: Node | null = node;
+	while (current && current !== editable && !isBlock(current)) current = current.parentNode;
+
+	return current && current !== editable ? (current as HTMLElement) : null;
+}
+
+/**
+ * Where to insert at the editor level: the node the new content goes before (null — at the end).
+ *
+ * A position addresses a child only when the container is the editor itself. A caret inside stray
+ * top-level text sits in a text node, and there the offset counts characters rather than children:
+ * taken as a child index it would send the insertion to an arbitrary place. From such a node we
+ * measure the node itself and insert after it, which is what a caret inside it asks for.
+ */
+function topLevelRef(editable: HTMLElement, range: Range): ChildNode | null {
+	const container = range.startContainer;
+	if (container === editable) return editable.childNodes[range.startOffset] ?? null;
+
+	let node: Node = container;
+	while (node.parentNode && node.parentNode !== editable) node = node.parentNode;
+
+	return node.parentNode === editable ? (node as ChildNode).nextSibling : null;
+}
+
 /** Enter в multiline: разбить текущий блок по каретке; хвост становится блоком типа `type`. */
 export function insertParagraph(editable: HTMLElement, type: BlockType = DEFAULT_BLOCK) {
 	const selection = innerSelection(editable);
@@ -192,20 +222,18 @@ export function insertParagraph(editable: HTMLElement, type: BlockType = DEFAULT
 	range.deleteContents();
 
 	// текущий блок (ближайший блочный предок внутри редактора)
-	let para: Node | null = range.startContainer;
-	while (para && para !== editable && !isBlock(para)) para = para.parentNode;
+	const para = blockOf(editable, range.startContainer);
 
 	// каретка не внутри абзаца — создаём абзац сразу с видимым результатом (иначе Enter «срабатывает со 2-го раза»)
-	if (!para || para === editable) {
+	if (!para) {
 		const next = createBlock(type);
 		if (editable.childNodes.length === 0) {
 			// пустой редактор: пустая строка-источник + новая строка с кареткой
-			editable.appendChild(emptyParagraph());
+			editable.appendChild(createBlock(DEFAULT_BLOCK));
 			editable.appendChild(next);
 		} else {
 			// каретка на уровне редактора между/после абзацев — вставляем новый абзац в эту позицию
-			const ref = editable.childNodes[range.startOffset] ?? null;
-			editable.insertBefore(next, ref);
+			editable.insertBefore(next, topLevelRef(editable, range));
 		}
 		caretToStart(next);
 		return;
@@ -217,21 +245,54 @@ export function insertParagraph(editable: HTMLElement, type: BlockType = DEFAULT
 	tail.setStart(range.endContainer, range.endOffset);
 	const fragment = tail.extractContents();
 
+	// Выходим из блока, а за ним уже стоит пустой абзац — переходим в него. Иначе одно нажатие
+	// давало бы две пустые строки: одна тут заводится, вторая уже была заведена под каретку.
+	const following = para.nextElementSibling;
+	const empty = !(fragment.textContent ?? "") && !fragment.querySelector("br");
+
+	if (empty && following && blockTypeOf(following) === type && !(following.textContent ?? "")) {
+		fillEmptyParagraph(para);
+		caretToStart(following);
+
+		return;
+	}
+
 	const next = document.createElement(BLOCK_TYPES[type].tag);
 	next.appendChild(fragment);
-	(para as ChildNode).after(next);
+	para.after(next);
 
 	// хвост уехал в блок другого типа — его правила распространяются и на содержимое
 	if (!BLOCK_TYPES[type].inline) unwrapFormatting(next);
 
 	// extractContents в конце абзаца оставляет пустой текст-узел → <p></p> без заполнителя
 	// (невидим/нефокусируем, каретка не встаёт). Чистим и ставим <br> в опустевшие абзацы.
-	fillEmptyParagraph(para as HTMLElement);
+	fillEmptyParagraph(para);
 	fillEmptyParagraph(next);
 
 	caretToStart(next);
 }
 
+/**
+ * Разрезает элемент по каретке: содержимое после неё уходит в такой же элемент следом,
+ * а диапазон встаёт между половинами — вставленное туда окажется снаружи обоих. Пустые
+ * половины не оставляем: печатать в них было бы нечего, а каретка попадала бы внутрь.
+ */
+function splitElement(el: HTMLElement, range: Range) {
+	const tail = document.createRange();
+	tail.selectNodeContents(el);
+	tail.setStart(range.startContainer, range.startOffset);
+
+	const rest = el.cloneNode(false) as HTMLElement;
+	rest.appendChild(tail.extractContents());
+
+	if (rest.textContent) el.after(rest);
+
+	range.setStartAfter(el);
+	range.collapse(true);
+
+	if (!el.textContent) el.remove();
+}
+
 /** Shift/Ctrl+Enter в multiline: вставить мягкий перенос <br>. */
 export function insertSoftBreak(editable: HTMLElement) {
 	const selection = innerSelection(editable);
@@ -240,6 +301,13 @@ export function insertSoftBreak(editable: HTMLElement) {
 	const range = selection.getRangeAt(0);
 	range.deleteContents();
 
+	// Перенос не живёт в моноширинном: значение берёт оттуда голый текст, и новая строка
+	// пропала бы — поле показывало бы две, а получатель увидел одну. Разрезаем тег и ставим
+	// перенос между половинами: форматирование продолжается на новой строке, только если
+	// там что-то осталось.
+	const literal = literalAncestor(range.startContainer, editable);
+	if (literal) splitElement(literal, range);
+
 	const br = document.createElement("br");
 	range.insertNode(br);
 
@@ -265,17 +333,15 @@ export function insertSoftBreak(editable: HTMLElement) {
 
 /** Вставляет санитизированные абзацы <p> в позицию каретки, разбивая текущий абзац. */
 export function insertPastedParagraphs(editable: HTMLElement, paras: HTMLElement[], range: Range) {
-	let para: Node | null = range.startContainer;
-	while (para && para !== editable && !isBlock(para)) para = para.parentNode;
+	const block = blockOf(editable, range.startContainer);
 
 	// каретка не внутри абзаца (пустой редактор / уровень редактора) — вставляем абзацы как есть
-	if (!para || para === editable) {
-		const ref = editable.childNodes[range.startOffset] ?? null;
+	if (!block) {
+		const ref = topLevelRef(editable, range);
 		for (const p of paras) editable.insertBefore(p, ref);
 		return;
 	}
 
-	const block = para as HTMLElement;
 	// Вставка в цитату или код остаётся в них: разорвать блок посреди вставки — не то,
 	// чего ждут, а тип целевого блока диктует и правила его содержимого.
 	const type = blockTypeOf(block) ?? DEFAULT_BLOCK;

package/source/format-config.ts

@@ -104,6 +104,17 @@ interface FormatToolDef {
 	matchTags: string[];
 	/** Маркер в Markdown. */
 	md: string;
+	/**
+	 * Маркеры того же инструмента из чужих диалектов: разбираются наравне с основным, но сами
+	 * не ставятся. Текст, размеченный ими, встречается в старых сообщениях, и показывать его
+	 * сырыми символами — значит показывать не то, что увидит получатель.
+	 */
+	mdAliases?: string[];
+	/**
+	 * Содержимое буквально: разметка внутри не разбирается и не сохраняется, значение берёт
+	 * оттуда голый текст. Перенос строки в таком теге тоже не живёт — он его разрезает.
+	 */
+	literal?: boolean;
 	/** Клавиша для Ctrl/Cmd-хоткея (пусто — без хоткея). */
 	hotkey: string;
 	/** Подсказка на кнопке. */
@@ -115,6 +126,9 @@ export const FORMAT_TOOLS: Record<FormatTool, FormatToolDef> = {
 		tag: "b",
 		matchTags: ["B", "STRONG"],
 		md: "**",
+		// Одинарная звёздочка — жирный в WhatsApp; так размечены сообщения, набранные до
+		// редактора, и получатель увидит их жирными.
+		mdAliases: ["*"],
 		hotkey: "b",
 		title: "Жирный",
 	},
@@ -152,6 +166,7 @@ export const FORMAT_TOOLS: Record<FormatTool, FormatToolDef> = {
 		tag: "code",
 		matchTags: ["CODE"],
 		md: "`",
+		literal: true,
 		hotkey: "",
 		title: "Моноширинный",
 	},
@@ -210,19 +225,20 @@ export function parseEditorActions(value: string | null): EditorAction[] {
 }
 
 /**
- * Разбирает значение атрибута data-blocks. Блоки подключаются явно: без атрибута доступен
- * только обычный текст. Он в наборе есть всегда — иначе блок некуда было бы вернуть.
+ * Разбирает значение атрибута data-blocks. Без атрибута доступны все типы; пустое значение
+ * оставляет только обычный текст — им ограничивают поле, где цитаты и код ни к чему.
  */
 export function parseBlockTypes(value: string | null): BlockType[] {
-	return value === null ? [DEFAULT_BLOCK] : normalizeBlockTypes(parseList(value, ALL_BLOCK_TYPES));
+	return value === null ? ALL_BLOCK_TYPES.slice() : normalizeBlockTypes(parseList(value, ALL_BLOCK_TYPES));
 }
 
 /**
  * Приводит набор типов к порядку объявления. Обычный текст в наборе есть всегда: им становится
- * содержимое, не попавшее ни в какой блок, и в него же блок возвращают.
+ * содержимое, не попавшее ни в какой блок, и в него же блок возвращают. Набор не задан — берём
+ * все типы; ограничивают их явным списком.
  */
 export function normalizeBlockTypes(types: BlockType[] | undefined): BlockType[] {
-	if (!types) return [DEFAULT_BLOCK];
+	if (!types) return ALL_BLOCK_TYPES.slice();
 
 	const list = ALL_BLOCK_TYPES.filter((type) => types.includes(type));
 

package/source/format.ts

@@ -36,6 +36,7 @@ export {
 	restoreSelection,
 	mapCharOffset,
 	activeFormats,
+	emptyFormatAt,
 	toggleFormat,
 	clearFormat,
 	clearAllFormat,
@@ -51,6 +52,7 @@ export {
 	blocksInRange,
 	createBlock,
 	normalizeWhitespace,
+	mergeAdjacentBlocks,
 	normalizeParagraphs,
 	ensureParagraphs,
 } from "./paragraphs";

package/source/history.ts

@@ -68,12 +68,19 @@ export class EditorHistory {
 		const top = this.__undo[this.__undo.length - 1];
 		if (top && top.html === snap.html) return; // состояние не изменилось — не дублируем
 
+		this.__push(snap);
+		this.__redo = [];
+	}
+
+	// Puts a snapshot on the undo stack, dropping the oldest ones beyond the limits. Every push
+	// goes through here: redo adds a snapshot just like an edit does, and without trimming the
+	// history would outgrow the limits over a run of undo/redo.
+	private __push(snap: Snapshot): void {
 		this.__undo.push(snap);
 		this.__chars += snap.html.length;
+
 		while (this.__undo.length > MAX_DEPTH || (this.__chars > MAX_CHARS && this.__undo.length > 1))
 			this.__chars -= this.__undo.shift()!.html.length;
-
-		this.__redo = [];
 	}
 
 	/** Откатить на шаг назад. Возвращает false, если откатывать нечего. */
@@ -93,9 +100,7 @@ export class EditorHistory {
 		const next = this.__redo.pop();
 		if (!next) return false;
 
-		const current = this.__snapshot();
-		this.__undo.push(current);
-		this.__chars += current.html.length;
+		this.__push(this.__snapshot());
 		this.__restore(next);
 		this.__lastKind = null;
 		return true;

package/source/paragraphs.ts

@@ -154,11 +154,53 @@ export function normalizeWhitespace(root: HTMLElement) {
  * Нормализует абзацы многострочного режима: удаляет пустые абзацы (без текстового содержимого).
  * Если содержимого нет вовсе — редактор остаётся пустым (показывается placeholder).
  */
-export function normalizeParagraphs(root: HTMLElement) {
+export function normalizeParagraphs(root: HTMLElement, merge = false) {
+	if (merge) mergeAdjacentBlocks(root);
+
 	for (const el of Array.from(root.children)) {
 		// Пустой блок другого типа не трогаем: его завели осознанно и в него сейчас будут писать,
 		// а пустая строка внутри кода вообще осмысленна сама по себе.
-		if (blockTypeOf(el) === DEFAULT_BLOCK && (el.textContent ?? "").trim() === "") el.remove();
+		if (blockTypeOf(el) !== DEFAULT_BLOCK || (el.textContent ?? "").trim() !== "") continue;
+
+		// Последний пустой абзац — это место, где оставили каретку: перенеслись на новую строку
+		// и ушли из поля. Убрав его, редактор схлопывал бы только что набранную строку. За блоком
+		// другого типа он к тому же единственное место вне цитаты или кода — без него правка
+		// запиралась бы внутри, хотя вышли оттуда как раз затем, чтобы писать дальше.
+		//
+		// В значение такой абзац не попадает (хвост обрезается), а единственный в поле — попадает
+		// под удаление: пустое поле должно оставаться пустым, иначе не покажется заглушка.
+		const previous = el.previousElementSibling;
+		const kept = previous && (!el.nextElementSibling || blockTypeOf(previous) !== DEFAULT_BLOCK);
+		if (kept) continue;
+
+		el.remove();
+	}
+}
+
+/**
+ * Склеивает соседние блоки одного типа — в режиме мягких переносов, где граница между блоками
+ * в значение не попадает. Подряд идущие строки с маркером цитаты разбор собирает в одну цитату,
+ * а два обычных абзаца там и вовсе неразличимы: пустой строки между ними на экране нет, а в
+ * значении она была бы. Два блока в поле показывали бы то, чего в сообщении не будет.
+ *
+ * Блоки с ограждением (код) не трогаем: у них есть свои границы, и два подряд разбираются
+ * ровно как два.
+ */
+export function mergeAdjacentBlocks(root: HTMLElement) {
+	for (const el of Array.from(root.children) as HTMLElement[]) {
+		const type = blockTypeOf(el);
+		if (!type || BLOCK_TYPES[type].fence) continue;
+
+		const previous = el.previousElementSibling;
+		if (!previous || blockTypeOf(previous) !== type) continue;
+
+		// Строки склеиваем переносом: между блоками была граница, а внутри блока её роль играет он.
+		// Если перенос там уже есть (заполнитель последней строки), он границей и станет — иначе
+		// между строками появилась бы пустая, которой на экране не было.
+		if (previous.lastChild?.nodeName !== "BR") previous.appendChild(document.createElement("br"));
+
+		while (el.firstChild) previous.appendChild(el.firstChild);
+		el.remove();
 	}
 }
 
@@ -201,12 +243,16 @@ export function ensureParagraphs(root: HTMLElement) {
 			continue;
 		}
 
-		// в непустом абзаце убираем краевые <br>-заполнители: иначе введённый текст
-		// оказывается рядом с лишним переносом (символ «съезжает» на новую строку).
-		// Внутренние <br> (мягкие переносы) сохраняются.
+		// Хвостовой перенос в одиночку — остаток заполнителя опустевшего абзаца: текст уже есть,
+		// а показывать за ним нечего. Два и больше — это набранные пустые строки плюс заполнитель,
+		// который их и делает видимыми (см. trimTrailingBreaks), и трогать их нельзя.
+		//
+		// Ведущие переносы не трогаем вовсе: заполнитель бывает только последним, а перенос
+		// в начале — это набранная пустая строка. Убрав его, редактор схлопывал бы её, стоило
+		// начать печатать в следующей.
 		if ((p.textContent ?? "").length > 0) {
-			while (p.firstChild && p.firstChild.nodeName === "BR") p.removeChild(p.firstChild);
-			while (p.lastChild && p.lastChild.nodeName === "BR") p.removeChild(p.lastChild);
+			const tail = p.lastChild;
+			if (tail?.nodeName === "BR" && tail.previousSibling?.nodeName !== "BR") p.removeChild(tail);
 		}
 	}
 }