@surrealdb/ui 1.2.12 → 1.2.13

package/tests/unit/MarkdownEditor/table.test.ts

@@ -1,119 +1,119 @@
 import {
-    gfmTableAddColumn,
-    gfmTableAddRow,
-    gfmTableRemoveColumn,
-    gfmTableRemoveRow,
-    locateGfmTableCells,
-    parseGfmTable,
-    serialiseGfmTable,
-    type TableModel,
+	gfmTableAddColumn,
+	gfmTableAddRow,
+	gfmTableRemoveColumn,
+	gfmTableRemoveRow,
+	locateGfmTableCells,
+	parseGfmTable,
+	serialiseGfmTable,
+	type TableModel,
 } from "@src/lib/markdown/tree/gfm-table";
 import { describe, expect, it } from "vitest";
 
 describe("GFM table", () => {
-    it("parses simple GFM tables", () => {
-        const source = "| a | b |\n| - | - |\n| 1 | 2 |";
-        const model = parseGfmTable(source);
-        expect(model).not.toBeNull();
-        expect(model?.headers).toEqual(["a", "b"]);
-        expect(model?.rows).toEqual([["1", "2"]]);
-    });
+	it("parses simple GFM tables", () => {
+		const source = "| a | b |\n| - | - |\n| 1 | 2 |";
+		const model = parseGfmTable(source);
+		expect(model).not.toBeNull();
+		expect(model?.headers).toEqual(["a", "b"]);
+		expect(model?.rows).toEqual([["1", "2"]]);
+	});
 
-    it("respects alignment markers", () => {
-        const source = "| a | b | c |\n| :- | :-: | -: |\n| 1 | 2 | 3 |";
-        const model = parseGfmTable(source);
-        expect(model?.alignments).toEqual(["left", "center", "right"]);
-    });
+	it("respects alignment markers", () => {
+		const source = "| a | b | c |\n| :- | :-: | -: |\n| 1 | 2 | 3 |";
+		const model = parseGfmTable(source);
+		expect(model?.alignments).toEqual(["left", "center", "right"]);
+	});
 
-    it("round trips a table preserving content", () => {
-        const source = "| Name | Score |\n| :--- | ----: |\n| Ari  | 12    |\n| Nova | 8     |";
-        const model = parseGfmTable(source);
-        if (!model) throw new Error("expected parse");
-        const serialised = serialiseGfmTable(model);
+	it("round trips a table preserving content", () => {
+		const source = "| Name | Score |\n| :--- | ----: |\n| Ari  | 12    |\n| Nova | 8     |";
+		const model = parseGfmTable(source);
+		if (!model) throw new Error("expected parse");
+		const serialised = serialiseGfmTable(model);
 
-        const reparsed = parseGfmTable(serialised);
-        expect(reparsed).not.toBeNull();
-        expect(reparsed?.headers).toEqual(model.headers);
-        expect(reparsed?.alignments).toEqual(model.alignments);
-        expect(reparsed?.rows).toEqual(model.rows);
-    });
+		const reparsed = parseGfmTable(serialised);
+		expect(reparsed).not.toBeNull();
+		expect(reparsed?.headers).toEqual(model.headers);
+		expect(reparsed?.alignments).toEqual(model.alignments);
+		expect(reparsed?.rows).toEqual(model.rows);
+	});
 
-    it("returns null for non-table input", () => {
-        expect(parseGfmTable("just a paragraph")).toBeNull();
-    });
+	it("returns null for non-table input", () => {
+		expect(parseGfmTable("just a paragraph")).toBeNull();
+	});
 });
 
 describe("locateGfmTableCells", () => {
-    it("locates the content start offset of each cell", () => {
-        const source = "| a | b |\n| - | - |\n| 1 | 2 |";
-        const cells = locateGfmTableCells(source);
-        expect(cells).not.toBeNull();
-        // Header content starts: 'a' at 2, 'b' at 6.
-        expect(cells?.headerOffsets).toEqual([2, 6]);
-        expect(source[cells?.headerOffsets[0] ?? -1]).toBe("a");
-        expect(source[cells?.headerOffsets[1] ?? -1]).toBe("b");
-        // Body row content starts: '1' and '2'.
-        expect(source[cells?.rowOffsets[0]?.[0] ?? -1]).toBe("1");
-        expect(source[cells?.rowOffsets[0]?.[1] ?? -1]).toBe("2");
-    });
+	it("locates the content start offset of each cell", () => {
+		const source = "| a | b |\n| - | - |\n| 1 | 2 |";
+		const cells = locateGfmTableCells(source);
+		expect(cells).not.toBeNull();
+		// Header content starts: 'a' at 2, 'b' at 6.
+		expect(cells?.headerOffsets).toEqual([2, 6]);
+		expect(source[cells?.headerOffsets[0] ?? -1]).toBe("a");
+		expect(source[cells?.headerOffsets[1] ?? -1]).toBe("b");
+		// Body row content starts: '1' and '2'.
+		expect(source[cells?.rowOffsets[0]?.[0] ?? -1]).toBe("1");
+		expect(source[cells?.rowOffsets[0]?.[1] ?? -1]).toBe("2");
+	});
 
-    it("handles ragged padding and missing outer pipes", () => {
-        const source = "Name | Score\n--- | ---\nAri  |   12";
-        const cells = locateGfmTableCells(source);
-        expect(cells).not.toBeNull();
-        expect(source.slice(cells?.headerOffsets[0] ?? 0, (cells?.headerOffsets[0] ?? 0) + 4)).toBe(
-            "Name",
-        );
-        expect(source.slice(cells?.headerOffsets[1] ?? 0, (cells?.headerOffsets[1] ?? 0) + 5)).toBe(
-            "Score",
-        );
-        expect(source[cells?.rowOffsets[0]?.[1] ?? -1]).toBe("1");
-    });
+	it("handles ragged padding and missing outer pipes", () => {
+		const source = "Name | Score\n--- | ---\nAri  |   12";
+		const cells = locateGfmTableCells(source);
+		expect(cells).not.toBeNull();
+		expect(source.slice(cells?.headerOffsets[0] ?? 0, (cells?.headerOffsets[0] ?? 0) + 4)).toBe(
+			"Name",
+		);
+		expect(source.slice(cells?.headerOffsets[1] ?? 0, (cells?.headerOffsets[1] ?? 0) + 5)).toBe(
+			"Score",
+		);
+		expect(source[cells?.rowOffsets[0]?.[1] ?? -1]).toBe("1");
+	});
 
-    it("returns null for non-table input", () => {
-        expect(locateGfmTableCells("just a paragraph")).toBeNull();
-    });
+	it("returns null for non-table input", () => {
+		expect(locateGfmTableCells("just a paragraph")).toBeNull();
+	});
 });
 
 describe("GFM table edits", () => {
-    const base: TableModel = {
-        headers: ["a", "b"],
-        alignments: ["default", "default"],
-        rows: [["1", "2"]],
-    };
+	const base: TableModel = {
+		headers: ["a", "b"],
+		alignments: ["default", "default"],
+		rows: [["1", "2"]],
+	};
 
-    it("adds an empty trailing column", () => {
-        const next = gfmTableAddColumn(base);
-        expect(next.headers).toEqual(["a", "b", ""]);
-        expect(next.alignments).toHaveLength(3);
-        expect(next.rows).toEqual([["1", "2", ""]]);
-    });
+	it("adds an empty trailing column", () => {
+		const next = gfmTableAddColumn(base);
+		expect(next.headers).toEqual(["a", "b", ""]);
+		expect(next.alignments).toHaveLength(3);
+		expect(next.rows).toEqual([["1", "2", ""]]);
+	});
 
-    it("removes the last column but keeps at least one", () => {
-        const next = gfmTableRemoveColumn(base);
-        expect(next.headers).toEqual(["a"]);
-        expect(next.rows).toEqual([["1"]]);
-        const single: TableModel = { headers: ["only"], alignments: ["default"], rows: [["x"]] };
-        expect(gfmTableRemoveColumn(single)).toEqual(single);
-    });
+	it("removes the last column but keeps at least one", () => {
+		const next = gfmTableRemoveColumn(base);
+		expect(next.headers).toEqual(["a"]);
+		expect(next.rows).toEqual([["1"]]);
+		const single: TableModel = { headers: ["only"], alignments: ["default"], rows: [["x"]] };
+		expect(gfmTableRemoveColumn(single)).toEqual(single);
+	});
 
-    it("adds an empty trailing row sized to the columns", () => {
-        const next = gfmTableAddRow(base);
-        expect(next.rows).toEqual([
-            ["1", "2"],
-            ["", ""],
-        ]);
-    });
+	it("adds an empty trailing row sized to the columns", () => {
+		const next = gfmTableAddRow(base);
+		expect(next.rows).toEqual([
+			["1", "2"],
+			["", ""],
+		]);
+	});
 
-    it("removes the last row and is a no-op with no rows", () => {
-        expect(gfmTableRemoveRow(base).rows).toEqual([]);
-        const empty: TableModel = { headers: ["a"], alignments: ["default"], rows: [] };
-        expect(gfmTableRemoveRow(empty)).toEqual(empty);
-    });
+	it("removes the last row and is a no-op with no rows", () => {
+		expect(gfmTableRemoveRow(base).rows).toEqual([]);
+		const empty: TableModel = { headers: ["a"], alignments: ["default"], rows: [] };
+		expect(gfmTableRemoveRow(empty)).toEqual(empty);
+	});
 
-    it("round-trips edits through serialise/parse", () => {
-        const widened = serialiseGfmTable(gfmTableAddColumn(base));
-        const reparsed = parseGfmTable(widened);
-        expect(reparsed?.headers).toEqual(["a", "b", ""]);
-    });
+	it("round-trips edits through serialise/parse", () => {
+		const widened = serialiseGfmTable(gfmTableAddColumn(base));
+		const reparsed = parseGfmTable(widened);
+		expect(reparsed?.headers).toEqual(["a", "b", ""]);
+	});
 });

package/tests/unit/MarkdownEditor/triggers.test.ts

@@ -6,30 +6,30 @@ import { createMarkdownLanguage } from "@src/lib/markdown/grammar/language";
 import { describe, expect, it } from "vitest";
 
 function createView(doc: string, cursor?: number | { anchor: number; head: number }): EditorView {
-    const state = EditorState.create({
-        doc,
-        extensions: [
-            createMarkdownLanguage({ extensions: [Callout] }),
-            markdownSnippetHandler,
-            markdownPairKeymap,
-        ],
-        selection:
-            typeof cursor === "number"
-                ? EditorSelection.cursor(cursor)
-                : cursor
-                  ? EditorSelection.range(cursor.anchor, cursor.head)
-                  : undefined,
-    });
-
-    const parent = document.createElement("div");
-    document.body.appendChild(parent);
-
-    return new EditorView({ state, parent });
+	const state = EditorState.create({
+		doc,
+		extensions: [
+			createMarkdownLanguage({ extensions: [Callout] }),
+			markdownSnippetHandler,
+			markdownPairKeymap,
+		],
+		selection:
+			typeof cursor === "number"
+				? EditorSelection.cursor(cursor)
+				: cursor
+					? EditorSelection.range(cursor.anchor, cursor.head)
+					: undefined,
+	});
+
+	const parent = document.createElement("div");
+	document.body.appendChild(parent);
+
+	return new EditorView({ state, parent });
 }
 
 /** Dispatch a Backspace through the registered key handlers. */
 function backspace(view: EditorView): boolean {
-    return runScopeHandlers(view, new KeyboardEvent("keydown", { key: "Backspace" }), "editor");
+	return runScopeHandlers(view, new KeyboardEvent("keydown", { key: "Backspace" }), "editor");
 }
 
 /**
@@ -39,206 +39,206 @@ function backspace(view: EditorView): boolean {
  * normal keystroke.
  */
 function type(view: EditorView, text: string): void {
-    const main = view.state.selection.main;
-    const handlers = view.state.facet(EditorView.inputHandler);
-    const buildTransaction = () => view.state.update(view.state.replaceSelection(text));
-    for (const handler of handlers) {
-        if (handler(view, main.from, main.to, text, buildTransaction)) {
-            return;
-        }
-    }
-    view.dispatch(buildTransaction());
+	const main = view.state.selection.main;
+	const handlers = view.state.facet(EditorView.inputHandler);
+	const buildTransaction = () => view.state.update(view.state.replaceSelection(text));
+	for (const handler of handlers) {
+		if (handler(view, main.from, main.to, text, buildTransaction)) {
+			return;
+		}
+	}
+	view.dispatch(buildTransaction());
 }
 
 describe("markdownSnippetHandler", () => {
-    it("expands triple backtick into a fenced code block with caret on the empty content line", () => {
-        const view = createView("``", 2);
-        type(view, "`");
+	it("expands triple backtick into a fenced code block with caret on the empty content line", () => {
+		const view = createView("``", 2);
+		type(view, "`");
 
-        expect(view.state.doc.toString()).toBe("```\n\n```");
-        expect(view.state.selection.main.empty).toBe(true);
-        // Caret on the empty middle line, after "```\n".
-        expect(view.state.selection.main.from).toBe(4);
+		expect(view.state.doc.toString()).toBe("```\n\n```");
+		expect(view.state.selection.main.empty).toBe(true);
+		// Caret on the empty middle line, after "```\n".
+		expect(view.state.selection.main.from).toBe(4);
 
-        view.destroy();
-    });
+		view.destroy();
+	});
 
-    it("preserves leading indent when expanding a fence inside a nested context", () => {
-        const view = createView("  ``", 4);
-        type(view, "`");
+	it("preserves leading indent when expanding a fence inside a nested context", () => {
+		const view = createView("  ``", 4);
+		type(view, "`");
 
-        expect(view.state.doc.toString()).toBe("  ```\n  \n  ```");
-        // Caret on the indented content line.
-        expect(view.state.selection.main.from).toBe(8);
+		expect(view.state.doc.toString()).toBe("  ```\n  \n  ```");
+		// Caret on the indented content line.
+		expect(view.state.selection.main.from).toBe(8);
 
-        view.destroy();
-    });
+		view.destroy();
+	});
 
-    it("expands a triple backtick typed one keystroke at a time", () => {
-        const view = createView("", 0);
-        type(view, "`");
-        type(view, "`");
-        type(view, "`");
+	it("expands a triple backtick typed one keystroke at a time", () => {
+		const view = createView("", 0);
+		type(view, "`");
+		type(view, "`");
+		type(view, "`");
 
-        expect(view.state.doc.toString()).toBe("```\n\n```");
-        expect(view.state.selection.main.from).toBe(4);
+		expect(view.state.doc.toString()).toBe("```\n\n```");
+		expect(view.state.selection.main.from).toBe(4);
 
-        view.destroy();
-    });
+		view.destroy();
+	});
 
-    it("does not expand a fence from a single backtick after text", () => {
-        const view = createView("abc", 3);
-        type(view, "`");
+	it("does not expand a fence from a single backtick after text", () => {
+		const view = createView("abc", 3);
+		type(view, "`");
 
-        // A lone backtick must auto-pair, never clobber the preceding text.
-        expect(view.state.doc.toString()).toBe("abc``");
-        expect(view.state.selection.main.from).toBe(4);
+		// A lone backtick must auto-pair, never clobber the preceding text.
+		expect(view.state.doc.toString()).toBe("abc``");
+		expect(view.state.selection.main.from).toBe(4);
 
-        view.destroy();
-    });
+		view.destroy();
+	});
 
-    it("does not expand a fence when the backticks are not at the line start", () => {
-        const view = createView("x ``", 4);
-        type(view, "`");
+	it("does not expand a fence when the backticks are not at the line start", () => {
+		const view = createView("x ``", 4);
+		type(view, "`");
 
-        expect(view.state.doc.toString()).toBe("x ```");
+		expect(view.state.doc.toString()).toBe("x ```");
 
-        view.destroy();
-    });
+		view.destroy();
+	});
 
-    it("does not expand a fence when there is content after the cursor on the same line", () => {
-        const view = createView("``rest", 2);
-        type(view, "`");
+	it("does not expand a fence when there is content after the cursor on the same line", () => {
+		const view = createView("``rest", 2);
+		type(view, "`");
 
-        expect(view.state.doc.toString()).toBe("```rest");
+		expect(view.state.doc.toString()).toBe("```rest");
 
-        view.destroy();
-    });
+		view.destroy();
+	});
 
-    it("does not expand a fence when typing inside an existing fenced code block", () => {
-        const view = createView("```js\nlet x``\n```", 13);
-        type(view, "`");
+	it("does not expand a fence when typing inside an existing fenced code block", () => {
+		const view = createView("```js\nlet x``\n```", 13);
+		type(view, "`");
 
-        expect(view.state.doc.toString()).toBe("```js\nlet x```\n```");
+		expect(view.state.doc.toString()).toBe("```js\nlet x```\n```");
 
-        view.destroy();
-    });
+		view.destroy();
+	});
 
-    it("wraps a non-empty selection with backticks", () => {
-        const view = createView("hello world", { anchor: 0, head: 5 });
-        type(view, "`");
+	it("wraps a non-empty selection with backticks", () => {
+		const view = createView("hello world", { anchor: 0, head: 5 });
+		type(view, "`");
 
-        expect(view.state.doc.toString()).toBe("`hello` world");
-        expect(view.state.selection.main.from).toBe(1);
-        expect(view.state.selection.main.to).toBe(6);
+		expect(view.state.doc.toString()).toBe("`hello` world");
+		expect(view.state.selection.main.from).toBe(1);
+		expect(view.state.selection.main.to).toBe(6);
 
-        view.destroy();
-    });
+		view.destroy();
+	});
 
-    it("wraps a selection with asterisks for italic and again for bold", () => {
-        const view = createView("hello world", { anchor: 0, head: 5 });
-        type(view, "*");
-        expect(view.state.doc.toString()).toBe("*hello* world");
+	it("wraps a selection with asterisks for italic and again for bold", () => {
+		const view = createView("hello world", { anchor: 0, head: 5 });
+		type(view, "*");
+		expect(view.state.doc.toString()).toBe("*hello* world");
 
-        type(view, "*");
-        expect(view.state.doc.toString()).toBe("**hello** world");
+		type(view, "*");
+		expect(view.state.doc.toString()).toBe("**hello** world");
 
-        view.destroy();
-    });
+		view.destroy();
+	});
 
-    it("wraps a selection with tildes for strikethrough", () => {
-        const view = createView("hello world", { anchor: 0, head: 5 });
-        type(view, "~");
-        type(view, "~");
+	it("wraps a selection with tildes for strikethrough", () => {
+		const view = createView("hello world", { anchor: 0, head: 5 });
+		type(view, "~");
+		type(view, "~");
 
-        expect(view.state.doc.toString()).toBe("~~hello~~ world");
+		expect(view.state.doc.toString()).toBe("~~hello~~ world");
 
-        view.destroy();
-    });
+		view.destroy();
+	});
 
-    it("wraps a selection as a markdown link with caret between the parens", () => {
-        const view = createView("hello world", { anchor: 0, head: 5 });
-        type(view, "[");
+	it("wraps a selection as a markdown link with caret between the parens", () => {
+		const view = createView("hello world", { anchor: 0, head: 5 });
+		type(view, "[");
 
-        expect(view.state.doc.toString()).toBe("[hello]() world");
-        expect(view.state.selection.main.empty).toBe(true);
-        expect(view.state.selection.main.from).toBe(8);
+		expect(view.state.doc.toString()).toBe("[hello]() world");
+		expect(view.state.selection.main.empty).toBe(true);
+		expect(view.state.selection.main.from).toBe(8);
 
-        view.destroy();
-    });
+		view.destroy();
+	});
 
-    it("does not wrap when the selection is inside a fenced code block", () => {
-        const view = createView("```js\nlet x = 1\n```", { anchor: 6, head: 11 });
-        type(view, "*");
+	it("does not wrap when the selection is inside a fenced code block", () => {
+		const view = createView("```js\nlet x = 1\n```", { anchor: 6, head: 11 });
+		type(view, "*");
 
-        const doc = view.state.doc.toString();
-        expect(doc).not.toContain("*let x *");
-        expect(doc).not.toContain("*let x ");
+		const doc = view.state.doc.toString();
+		expect(doc).not.toContain("*let x *");
+		expect(doc).not.toContain("*let x ");
 
-        view.destroy();
-    });
+		view.destroy();
+	});
 
-    it("auto-pairs a lone backtick for inline code", () => {
-        const view = createView("run ", 4);
-        type(view, "`");
+	it("auto-pairs a lone backtick for inline code", () => {
+		const view = createView("run ", 4);
+		type(view, "`");
 
-        expect(view.state.doc.toString()).toBe("run ``");
-        expect(view.state.selection.main.from).toBe(5);
+		expect(view.state.doc.toString()).toBe("run ``");
+		expect(view.state.selection.main.from).toBe(5);
 
-        view.destroy();
-    });
+		view.destroy();
+	});
 
-    it("auto-pairs and steps over brackets", () => {
-        const view = createView("", 0);
-        type(view, "(");
-        expect(view.state.doc.toString()).toBe("()");
-        expect(view.state.selection.main.from).toBe(1);
+	it("auto-pairs and steps over brackets", () => {
+		const view = createView("", 0);
+		type(view, "(");
+		expect(view.state.doc.toString()).toBe("()");
+		expect(view.state.selection.main.from).toBe(1);
 
-        type(view, ")");
-        expect(view.state.doc.toString()).toBe("()");
-        expect(view.state.selection.main.from).toBe(2);
+		type(view, ")");
+		expect(view.state.doc.toString()).toBe("()");
+		expect(view.state.selection.main.from).toBe(2);
 
-        view.destroy();
-    });
+		view.destroy();
+	});
 
-    it("does not double a closing bracket that was not auto-paired", () => {
-        const view = createView("foo", 3);
-        type(view, ")");
+	it("does not double a closing bracket that was not auto-paired", () => {
+		const view = createView("foo", 3);
+		type(view, ")");
 
-        expect(view.state.doc.toString()).toBe("foo)");
+		expect(view.state.doc.toString()).toBe("foo)");
 
-        view.destroy();
-    });
+		view.destroy();
+	});
 
-    it("suppresses emphasis auto-pairing directly in front of a word", () => {
-        const view = createView("word", 0);
-        type(view, "*");
+	it("suppresses emphasis auto-pairing directly in front of a word", () => {
+		const view = createView("word", 0);
+		type(view, "*");
 
-        expect(view.state.doc.toString()).toBe("*word");
-        expect(view.state.selection.main.from).toBe(1);
+		expect(view.state.doc.toString()).toBe("*word");
+		expect(view.state.selection.main.from).toBe(1);
 
-        view.destroy();
-    });
+		view.destroy();
+	});
 
-    it("deletes an empty auto-inserted pair with a single backspace", () => {
-        const view = createView("", 0);
-        type(view, "(");
-        expect(view.state.doc.toString()).toBe("()");
+	it("deletes an empty auto-inserted pair with a single backspace", () => {
+		const view = createView("", 0);
+		type(view, "(");
+		expect(view.state.doc.toString()).toBe("()");
 
-        backspace(view);
-        expect(view.state.doc.toString()).toBe("");
-        expect(view.state.selection.main.from).toBe(0);
+		backspace(view);
+		expect(view.state.doc.toString()).toBe("");
+		expect(view.state.selection.main.from).toBe(0);
 
-        view.destroy();
-    });
+		view.destroy();
+	});
 
-    it("leaves a non-empty pair to the default backspace", () => {
-        const view = createView("(x)", 2);
-        // The pair handler declines (no empty pair around the caret), so the
-        // default backspace binding is left to run.
-        expect(backspace(view)).toBe(false);
-        expect(view.state.doc.toString()).toBe("(x)");
+	it("leaves a non-empty pair to the default backspace", () => {
+		const view = createView("(x)", 2);
+		// The pair handler declines (no empty pair around the caret), so the
+		// default backspace binding is left to run.
+		expect(backspace(view)).toBe(false);
+		expect(view.state.doc.toString()).toBe("(x)");
 
-        view.destroy();
-    });
+		view.destroy();
+	});
 });