@surrealdb/ui 1.2.16 → 1.2.17

package/tests/unit/MarkdownEditor/slash-commands.test.ts

@@ -1,213 +0,0 @@
-import { EditorSelection, EditorState } from "@codemirror/state";
-import { EditorView } from "@codemirror/view";
-import { DEFAULT_SLASH_COMMANDS } from "@src/lib/markdown/editor/slash/commands";
-import { slashDecorationsField } from "@src/lib/markdown/editor/slash/decorations";
-import { getSlashSession, slashSessionField } from "@src/lib/markdown/editor/slash/field";
-import { Callout } from "@src/lib/markdown/grammar/callout";
-import { createMarkdownLanguage } from "@src/lib/markdown/grammar/language";
-import { describe, expect, it } from "vitest";
-
-function createView(doc: string, cursor = doc.length): EditorView {
-	const state = EditorState.create({
-		doc,
-		extensions: [
-			createMarkdownLanguage({ extensions: [Callout] }),
-			slashSessionField,
-			slashDecorationsField,
-		],
-		selection: EditorSelection.cursor(cursor),
-	});
-
-	const parent = document.createElement("div");
-	document.body.appendChild(parent);
-
-	return new EditorView({ state, parent });
-}
-
-/** Simulate typing `text` one character at a time as `input.type` events. */
-function type(view: EditorView, text: string): void {
-	for (const char of text) {
-		const pos = view.state.selection.main.head;
-		view.dispatch({
-			changes: { from: pos, insert: char },
-			selection: EditorSelection.cursor(pos + 1),
-			userEvent: "input.type",
-		});
-	}
-}
-
-function command(id: string) {
-	const found = DEFAULT_SLASH_COMMANDS.find((c) => c.id === id);
-	if (!found) throw new Error(`unknown command ${id}`);
-	return found;
-}
-
-describe("slashSessionField", () => {
-	it("opens a session when typing / at the start of a line", () => {
-		const view = createView("", 0);
-		type(view, "/");
-
-		expect(getSlashSession(view.state)).toEqual({ from: 0, query: "" });
-
-		view.destroy();
-	});
-
-	it("opens a session when typing / after whitespace", () => {
-		const view = createView("foo ", 4);
-		type(view, "/");
-
-		expect(getSlashSession(view.state)?.from).toBe(4);
-
-		view.destroy();
-	});
-
-	it("does not open a session mid-word", () => {
-		const view = createView("foo", 3);
-		type(view, "/");
-
-		expect(getSlashSession(view.state)).toBeNull();
-
-		view.destroy();
-	});
-
-	it("does not open a session inside a fenced code block", () => {
-		const view = createView("```\n\n```", 4);
-		type(view, "/");
-
-		expect(getSlashSession(view.state)).toBeNull();
-
-		view.destroy();
-	});
-
-	it("tracks the query as the user continues typing", () => {
-		const view = createView("", 0);
-		type(view, "/head");
-
-		expect(getSlashSession(view.state)?.query).toBe("head");
-
-		view.destroy();
-	});
-
-	it("keeps the session open across a single space but closes on two", () => {
-		const view = createView("", 0);
-		type(view, "/a ");
-		expect(getSlashSession(view.state)?.query).toBe("a ");
-
-		type(view, " ");
-		expect(getSlashSession(view.state)).toBeNull();
-
-		view.destroy();
-	});
-
-	it("closes the session when the slash is deleted", () => {
-		const view = createView("", 0);
-		type(view, "/h");
-		const slashPos = getSlashSession(view.state)?.from ?? -1;
-
-		view.dispatch({
-			changes: { from: slashPos, to: slashPos + 1 },
-			userEvent: "delete",
-		});
-
-		expect(getSlashSession(view.state)).toBeNull();
-
-		view.destroy();
-	});
-
-	it("closes the session when the caret moves before the slash", () => {
-		const view = createView("", 0);
-		type(view, "/h");
-
-		view.dispatch({ selection: EditorSelection.cursor(0) });
-
-		expect(getSlashSession(view.state)).toBeNull();
-
-		view.destroy();
-	});
-});
-
-describe("DEFAULT_SLASH_COMMANDS", () => {
-	it("replaces the /query range with a heading prefix and positions the caret", () => {
-		const view = createView("", 0);
-		type(view, "/h1");
-		const session = getSlashSession(view.state);
-		expect(session).not.toBeNull();
-
-		command("heading-1").run(view, {
-			from: session?.from ?? 0,
-			to: view.state.selection.main.head,
-		});
-
-		expect(view.state.doc.toString()).toBe("# ");
-		expect(view.state.selection.main.head).toBe(2);
-		// Replacing the slash text closes the session.
-		expect(getSlashSession(view.state)).toBeNull();
-
-		view.destroy();
-	});
-
-	it("inserts a fenced code block with the caret on the empty middle line", () => {
-		const view = createView("", 0);
-		type(view, "/code");
-
-		command("code-block").run(view, {
-			from: 0,
-			to: view.state.selection.main.head,
-		});
-
-		expect(view.state.doc.toString()).toBe("```\n\n```");
-		expect(view.state.selection.main.head).toBe(4);
-
-		view.destroy();
-	});
-});
-
-function collectDecorations(view: EditorView) {
-	const set = view.state.field(slashDecorationsField);
-	const marks: Array<{ from: number; to: number }> = [];
-	let widgets = 0;
-
-	set.between(0, view.state.doc.length, (from, to, deco) => {
-		if (deco.spec.widget) {
-			widgets += 1;
-		} else {
-			marks.push({ from, to });
-		}
-	});
-
-	return { marks, widgets };
-}
-
-describe("slashDecorationsField", () => {
-	it("emits no decorations when there is no active session", () => {
-		const view = createView("hello", 5);
-
-		expect(collectDecorations(view)).toEqual({ marks: [], widgets: 0 });
-
-		view.destroy();
-	});
-
-	it("highlights the lone slash and shows the placeholder when the query is empty", () => {
-		const view = createView("", 0);
-		type(view, "/");
-
-		const { marks, widgets } = collectDecorations(view);
-		// Mark wraps the slash and the trailing placeholder widget (0..2).
-		expect(marks).toEqual([{ from: 0, to: 2 }]);
-		expect(widgets).toBe(1);
-
-		view.destroy();
-	});
-
-	it("extends the highlight over the query and drops the placeholder once text is typed", () => {
-		const view = createView("", 0);
-		type(view, "/head");
-
-		const { marks, widgets } = collectDecorations(view);
-		// Mark spans the slash + "head" (positions 0..5).
-		expect(marks).toEqual([{ from: 0, to: 5 }]);
-		expect(widgets).toBe(0);
-
-		view.destroy();
-	});
-});

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

@@ -1,83 +0,0 @@
-import { EditorSelection, EditorState } from "@codemirror/state";
-import { markdownTableFormatter, tableFormatSpec } from "@src/lib/markdown/editor/table-format";
-import { describe, expect, it } from "vitest";
-
-function stateWith(doc: string, caret: number): EditorState {
-	return EditorState.create({
-		doc,
-		selection: EditorSelection.cursor(caret),
-		extensions: [markdownTableFormatter()],
-	});
-}
-
-describe("tableFormatSpec", () => {
-	it("aligns columns and pads cells with trailing spaces", () => {
-		const doc = "| a | b |\n| - | - |\n| longvalue | y |";
-		const state = stateWith(doc, doc.indexOf("longvalue"));
-		const spec = tableFormatSpec(state);
-		expect(spec).not.toBeNull();
-		const next = state.update(spec ?? {}).state;
-		expect(next.doc.toString()).toBe(
-			["| a         | b   |", "| --------- | --- |", "| longvalue | y   |"].join("\n"),
-		);
-	});
-
-	it("returns null for an already-formatted table", () => {
-		const doc = ["| a         | b   |", "| --------- | --- |", "| longvalue | y   |"].join(
-			"\n",
-		);
-		const state = stateWith(doc, doc.indexOf("longvalue"));
-		expect(tableFormatSpec(state)).toBeNull();
-	});
-
-	it("returns null when the caret is not in a table", () => {
-		const doc = "just a paragraph with a | pipe";
-		const state = stateWith(doc, 3);
-		expect(tableFormatSpec(state)).toBeNull();
-	});
-
-	it("keeps the caret within the edited cell after formatting", () => {
-		const doc = "| a | b |\n| - | - |\n| longvalue | y |";
-		// Caret right after "long" inside the body cell.
-		const caret = doc.indexOf("longvalue") + 4;
-		const state = stateWith(doc, caret);
-		const spec = tableFormatSpec(state);
-		const next = state.update(spec ?? {}).state;
-		const formatted = next.doc.toString();
-		const cellStart = formatted.indexOf("longvalue");
-		expect(next.selection.main.head).toBe(cellStart + 4);
-	});
-});
-
-describe("markdownTableFormatter", () => {
-	it("reformats the table after an edit inside it", () => {
-		const doc = "| a | b |\n| - | - |\n| x | y |";
-		const state = EditorState.create({
-			doc,
-			selection: EditorSelection.cursor(doc.indexOf("x") + 1),
-			extensions: [markdownTableFormatter()],
-		});
-		// Type "tra" after "x" → "xtra", which widens column 1.
-		const tr = state.update({
-			changes: { from: doc.indexOf("x") + 1, insert: "tra" },
-			selection: EditorSelection.cursor(doc.indexOf("x") + 4),
-		});
-		const next = tr.state;
-		expect(next.doc.toString()).toContain("| xtra | y   |");
-	});
-
-	it("does not loop on its own formatting transaction", () => {
-		const doc = "| a | b |\n| - | - |\n| x | y |";
-		const state = EditorState.create({
-			doc,
-			selection: EditorSelection.cursor(doc.indexOf("x") + 1),
-			extensions: [markdownTableFormatter()],
-		});
-		const tr = state.update({
-			changes: { from: doc.indexOf("x") + 1, insert: "tra" },
-		});
-		// A single user edit produces a stable, idempotent result.
-		const again = tr.state.update({ selection: EditorSelection.cursor(0) });
-		expect(again.state.doc.toString()).toBe(tr.state.doc.toString());
-	});
-});

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

@@ -1,119 +0,0 @@
-import {
-	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("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);
-
-		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();
-	});
-});
-
-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("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();
-	});
-});
-
-describe("GFM table edits", () => {
-	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("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("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", ""]);
-	});
-});

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

@@ -1,244 +0,0 @@
-import { EditorSelection, EditorState } from "@codemirror/state";
-import { EditorView, runScopeHandlers } from "@codemirror/view";
-import { markdownPairKeymap, markdownSnippetHandler } from "@src/lib/markdown/editor/snippets";
-import { Callout } from "@src/lib/markdown/grammar/callout";
-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 });
-}
-
-/** Dispatch a Backspace through the registered key handlers. */
-function backspace(view: EditorView): boolean {
-	return runScopeHandlers(view, new KeyboardEvent("keydown", { key: "Backspace" }), "editor");
-}
-
-/**
- * Simulate a single-character user input by walking the same input-handler
- * pipeline the editor uses. Falls back to a default insert when no handler
- * consumes the event so we exercise the trigger but otherwise behave like a
- * 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());
-}
-
-describe("markdownSnippetHandler", () => {
-	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);
-
-		view.destroy();
-	});
-
-	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);
-
-		view.destroy();
-	});
-
-	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);
-
-		view.destroy();
-	});
-
-	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);
-
-		view.destroy();
-	});
-
-	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 ```");
-
-		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, "`");
-
-		expect(view.state.doc.toString()).toBe("```rest");
-
-		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, "`");
-
-		expect(view.state.doc.toString()).toBe("```js\nlet x```\n```");
-
-		view.destroy();
-	});
-
-	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);
-
-		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");
-
-		type(view, "*");
-		expect(view.state.doc.toString()).toBe("**hello** world");
-
-		view.destroy();
-	});
-
-	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");
-
-		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, "[");
-
-		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();
-	});
-
-	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 ");
-
-		view.destroy();
-	});
-
-	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);
-
-		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);
-
-		type(view, ")");
-		expect(view.state.doc.toString()).toBe("()");
-		expect(view.state.selection.main.from).toBe(2);
-
-		view.destroy();
-	});
-
-	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)");
-
-		view.destroy();
-	});
-
-	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);
-
-		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("()");
-
-		backspace(view);
-		expect(view.state.doc.toString()).toBe("");
-		expect(view.state.selection.main.from).toBe(0);
-
-		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)");
-
-		view.destroy();
-	});
-});