Skip to content

Build your personal knowledge base with Trilium Notes

client/text editor/block references: fix some issues

Adorian Doranfdef3074a680
diff --git a/packages/commons/src/lib/block_reference.spec.ts b/packages/commons/src/lib/block_reference.spec.ts
index e1698fc4ae..05a71d7256 100644
--- a/packages/commons/src/lib/block_reference.spec.ts
+++ b/packages/commons/src/lib/block_reference.spec.ts
@@ -6,6 +6,7 @@ import {
encodeBlockParameter,
formatBlockRange,
getEditableBlockRun,
+ getListItemNumber,
isValidBlockId,
parseBlockRange,
resolveBlockRange,
@@ -155,18 +156,37 @@ describe("sliceToBlockReference", () => {
const list = el("ol", {}, el("li", {}, text("1")), text(" "), el("li", {}, text("2")),
el("li", {}, block("p", "x")));
const numberedList = el("ol", { start: "4" }, el("li", {}, text("4")), block("li", "x"));
+ const reversedList = el("ol", { reversed: "" }, block("li", "x", text("3")),
+ el("li", {}, text("2")), el("li", {}, text("1")));
+ const numberedReversedList = el("ol", { reversed: "", start: "10" },
+ el("li", {}, text("10")), block("li", "x"), el("li", {}, text("8")));
const bulletList = el("ul", {}, el("li", {}, text("a")), block("li", "x"));
- for (const container of [ list, numberedList, bulletList ]) {
+ for (const container of [
+ list, numberedList, reversedList, numberedReversedList, bulletList
+ ]) {
sliceToBlockReference(el("div", {}, container), "x");
}
expect(list.getAttribute("start")).toBe("3");
expect(numberedList.getAttribute("start")).toBe("5");
+ expect(reversedList.getAttribute("start")).toBe("3");
+ expect(numberedReversedList.getAttribute("start")).toBe("9");
expect(bulletList.getAttribute("start")).toBeNull();
});
});
+describe("getListItemNumber", () => {
+ it("counts up from the start of a list, and down in a reversed list", () => {
+ const items = () => [ el("li", {}), text(" "), el("li", {}) ];
+
+ expect(getListItemNumber(el("ol", {}, ...items()), 1)).toBe(2);
+ expect(getListItemNumber(el("ol", { start: "5" }, ...items()), -2)).toBe(3);
+ expect(getListItemNumber(el("ol", { reversed: "" }, ...items()), 0)).toBe(2);
+ expect(getListItemNumber(el("ol", { reversed: "", start: "5" }, ...items()), -1)).toBe(6);
+ });
+});
+
describe("getEditableBlockRun", () => {
it("finds a single block, and the blocks of a range with their nested ancestors", () => {
const single = block("p", "a");
diff --git a/packages/commons/src/lib/block_reference.ts b/packages/commons/src/lib/block_reference.ts
index abfe671170..4d84fad24b 100644
--- a/packages/commons/src/lib/block_reference.ts
+++ b/packages/commons/src/lib/block_reference.ts
@@ -136,6 +136,18 @@ export function getEditableBlockRun<T extends BlockNode>(
return isContainer ? { parent, first, last } : null;
}
+/**
+ * The number that the item at `index` of the ordered `list` shows, as the browser numbers it. A
+ * negative `index` counts on before the first item.
+ */
+export function getListItemNumber(list: BlockNode, index: number) {
+ const isReversed = typeof list.getAttribute?.("reversed") === "string";
+ const start = Number.parseInt(list.getAttribute?.("start") ?? "", 10);
+ const itemCount = Array.from(list.childNodes).filter((node) => isTag(node, "LI")).length;
+ const first = Number.isNaN(start) ? (isReversed ? itemCount : 1) : start;
+ return isReversed ? first - index : first + index;
+}
+
const RUN_CONTAINERS = new Set([
"ASIDE", "BLOCKQUOTE", "DETAILS", "DIV", "LI", "OL", "SECTION", "UL"
]);
@@ -170,8 +182,8 @@ function sliceToBlockRange(root: BlockNode, start: BlockNode, end: BlockNode) {
for (let node = start; node !== root && node.parentNode; node = node.parentNode) {
const siblings = Array.from(node.parentNode.childNodes);
const removed = siblings.slice(0, siblings.indexOf(node));
+ keepListNumbering(node.parentNode, removed.filter((other) => isTag(other, "LI")).length);
removeNodes(removed);
- keepListNumbering(node.parentNode, removed);
}
for (let node = end; node !== root && node.parentNode; node = node.parentNode) {
@@ -193,15 +205,11 @@ function removeNodes(nodes: BlockNode[]) {
}
}
-function keepListNumbering(list: BlockNode, removed: BlockNode[]) {
- const removedItems = removed.filter((node) => isTag(node, "LI")).length;
- if (!isTag(list, "OL") || !removedItems) {
- return;
+/** Sets the `start` of `list` so that its item at `index` keeps its number once it comes first. */
+function keepListNumbering(list: BlockNode, index: number) {
+ if (isTag(list, "OL")) {
+ list.setAttribute?.("start", String(getListItemNumber(list, index)));
}
-
- const start = Number.parseInt(list.getAttribute?.("start") ?? "", 10);
- const firstNumber = Number.isNaN(start) ? 1 : start;
- list.setAttribute?.("start", String(firstNumber + removedItems));
}
function isTag(node: BlockNode, tagName: string) {
diff --git a/packages/trilium-core/src/services/block_ranges.spec.ts b/packages/trilium-core/src/services/block_ranges.spec.ts
index 701719b7d7..85ed4d971b 100644
--- a/packages/trilium-core/src/services/block_ranges.spec.ts
+++ b/packages/trilium-core/src/services/block_ranges.spec.ts
@@ -64,18 +64,40 @@ describe("replaceBlockRangeContent", () => {
);
});
+ it("applies the list properties edited with the items to the whole list", () => {
+ const items = `<li><p data-trilium-block-id="a">4</p></li>`
+ + `<li><p data-trilium-block-id="b">5</p></li></ol>`;
+ const rest = LIST.slice(LIST.indexOf(">") + 1);
+ const replace = (openTag: string) => replaceBlockRangeContent(LIST, "a:b", openTag + items);
+
+ expect(replace(`<ol start="10" class="numbered">`)).toBe(
+ `<ol start="9" class="numbered">${rest}`
+ );
+ expect(replace(`<ol start="4" class="numbered" style="list-style-type:lower-roman;">`))
+ .toBe(`<ol start="3" class="numbered" style="list-style-type:lower-roman;">${rest}`);
+ expect(replace(`<ol start="4" class="numbered" reversed>`)).toBe(
+ `<ol start="5" class="numbered" reversed>${rest}`
+ );
+ });
+
it("splits the list around list items that change into other content", () => {
const paragraph = `<p data-trilium-block-id="a">Not an item</p>`;
const bullets = `<ul><li><p data-trilium-block-id="x">Bullet</p></li></ul>`;
+ const reversed = `<ol reversed><li>3</li><li><p data-trilium-block-id="a">2</p></li>`
+ + `<li>1</li></ol>`;
expect(replaceBlockRangeContent(LIST, "a:b", paragraph)).toBe(
`<ol start="3" class="numbered"><li><p data-trilium-block-id="x">3</p></li>\n</ol>`
+ paragraph
- + `<ol start="3" class="numbered"><li><p>6</p></li></ol>`
+ + `<ol start="6" class="numbered"><li><p>6</p></li></ol>`
);
expect(replaceBlockRangeContent(LIST, "x:a", bullets)).toBe(
- `${bullets}<ol start="3" class="numbered">`
+ `${bullets}<ol start="5" class="numbered">`
+ `<li><p data-trilium-block-id="b">5</p></li><li><p>6</p></li></ol>`
);
+ expect(replaceBlockRangeContent(reversed, "a", paragraph)).toBe(
+ `<ol reversed start="3"><li>3</li></ol>${paragraph}`
+ + `<ol reversed start="1"><li>1</li></ol>`
+ );
});
});
diff --git a/packages/trilium-core/src/services/block_ranges.ts b/packages/trilium-core/src/services/block_ranges.ts
index f7a9f9b21a..846b43f50c 100644
--- a/packages/trilium-core/src/services/block_ranges.ts
+++ b/packages/trilium-core/src/services/block_ranges.ts
@@ -1,7 +1,7 @@
import {
- BLOCK_ID_ATTRIBUTE, getEditableBlockRun, sliceToBlockReference
+ BLOCK_ID_ATTRIBUTE, getEditableBlockRun, getListItemNumber, sliceToBlockReference
} from "@triliumnext/commons";
-import { HTMLElement, parse } from "node-html-parser";
+import { HTMLElement, Node, parse } from "node-html-parser";
/**
* The HTML of the blocks of `content` that `block`, a `block` link parameter, points at, to edit
@@ -44,24 +44,47 @@ export function replaceBlockRangeContent(content: string, block: string, fragmen
}
const list = run.parent;
+ const items = list.childNodes.filter((node) => isTag(node, "LI"));
+ const firstChild = list.childNodes[0];
+ const lastChild = list.childNodes[list.childNodes.length - 1];
const editedList = getSameList(edited, list);
if (editedList) {
- return splice(content, start, end, editedList.innerHTML);
+ const firstNumber = getListItemNumber(editedList, -items.indexOf(run.first));
+ const openTag = getOpenTag(editedList, firstNumber);
+ const withItems = splice(content, start, end, editedList.innerHTML);
+ return openTag === getOpenTag(list, getListItemNumber(list, 0))
+ ? withItems
+ : splice(withItems, list.range[0], firstChild.range[0], openTag);
}
// The edited items are no longer items of the list, which splits around them.
- const firstItem = list.childNodes[0];
- const lastItem = list.childNodes[list.childNodes.length - 1];
- const openTag = content.slice(list.range[0], firstItem.range[0]);
- const closeTag = content.slice(lastItem.range[1], list.range[1]);
- const wrap = (items: string) => (items.trim() ? `${openTag}${items}${closeTag}` : "");
- const before = wrap(content.slice(firstItem.range[0], start));
- const after = wrap(content.slice(end, lastItem.range[1]));
+ const closeTag = content.slice(lastChild.range[1], list.range[1]);
+ const wrap = (html: string, firstNumber: number) => (
+ html.trim() ? `${getOpenTag(list, firstNumber)}${html}${closeTag}` : ""
+ );
+ const before = wrap(content.slice(firstChild.range[0], start), getListItemNumber(list, 0));
+ const after = wrap(
+ content.slice(end, lastChild.range[1]),
+ getListItemNumber(list, items.indexOf(run.last) + 1)
+ );
return splice(content, list.range[0], list.range[1], `${before}${edited.toString()}${after}`);
}
function isList(node: HTMLElement) {
- return node.tagName === "UL" || node.tagName === "OL";
+ return isTag(node, "UL") || isTag(node, "OL");
+}
+
+function isTag(node: Node, tagName: string) {
+ return node instanceof HTMLElement && node.tagName === tagName;
+}
+
+/** The opening tag of `list`, numbered from `firstNumber` when it is ordered. */
+function getOpenTag(list: HTMLElement, firstNumber: number) {
+ const tag = new HTMLElement(list.rawTagName, {}, list.rawAttrs);
+ if (isTag(tag, "OL")) {
+ tag.setAttribute("start", String(firstNumber));
+ }
+ return `<${tag.rawTagName}${tag.rawAttrs ? ` ${tag.rawAttrs}` : ""}>`;
}
function getBlockIdsOutside(root: HTMLElement, start: number, end: number) {