@surrealdb/ui 1.2.16 → 1.2.17

package/tests/unit/MarkdownEditor/indented-fence.test.ts

@@ -1,103 +0,0 @@
-import { markdownSourceFromString, parseMarkdownTree } from "@src/lib/markdown";
-import { readCodeText } from "@src/lib/markdown/tree/code-node";
-import { describe, expect, it } from "vitest";
-
-/** Reconstructed body text of the (single) FencedCode node. */
-function fencedCodeBody(text: string): string | null {
-	const tree = parseMarkdownTree(text);
-	const src = markdownSourceFromString(text);
-	let body: string | null = null;
-	tree.iterate({
-		enter: (n) => {
-			if (n.name === "FencedCode" && body === null) body = readCodeText(n.node, src);
-		},
-	});
-	return body;
-}
-
-/** Top-level node names of a parsed document. */
-function topLevelNodes(text: string): { name: string; text: string }[] {
-	const tree = parseMarkdownTree(text);
-	const src = markdownSourceFromString(text);
-	const out: { name: string; text: string }[] = [];
-	let ch = tree.topNode.firstChild;
-	while (ch) {
-		out.push({ name: ch.name, text: src.slice(ch.from, ch.to) });
-		ch = ch.nextSibling;
-	}
-	return out;
-}
-
-/** The source text of the (single) FencedCode node, or null if none. */
-function fencedCodeText(text: string): string | null {
-	const tree = parseMarkdownTree(text);
-	const src = markdownSourceFromString(text);
-	let found: string | null = null;
-	tree.iterate({
-		enter: (n) => {
-			if (n.name === "FencedCode" && found === null) found = src.slice(n.from, n.to);
-		},
-	});
-	return found;
-}
-
-describe("MarkdownEditor / indented fenced code closing", () => {
-	it("closes a tab-indented fence and does not swallow following content", () => {
-		const text = "\t```ts\n\tcode\n\t```\ntext";
-		const fence = fencedCodeText(text);
-		expect(fence).not.toBeNull();
-		expect(fence).not.toContain("text");
-		// The trailing paragraph survives as its own node.
-		expect(
-			topLevelNodes(text).some((n) => n.name === "Paragraph" && n.text.includes("text")),
-		).toBe(true);
-	});
-
-	it("closes a 4-space-indented fence and does not swallow following content", () => {
-		const text = "    ```ts\n    code\n    ```\ntext";
-		const fence = fencedCodeText(text);
-		expect(fence).not.toBeNull();
-		expect(fence).not.toContain("text");
-	});
-
-	it("does not let an indented fence swallow the closing </Tabs> tag", () => {
-		const text = [
-			"<Tabs>",
-			'\t<TabItem value="esm" label="ESM">',
-			"\t```ts",
-			"\tconst db = 1;",
-			"\t```",
-			"\t</TabItem>",
-			"</Tabs>",
-		].join("\n");
-		// </Tabs> and </TabItem> must be their own HTMLBlock nodes, not buried
-		// inside a runaway FencedCode.
-		const fence = fencedCodeText(text);
-		expect(fence).not.toContain("</TabItem>");
-		expect(fence).not.toContain("</Tabs>");
-		const names = topLevelNodes(text).map((n) => n.name);
-		expect(names.filter((n) => n === "HTMLBlock").length).toBeGreaterThanOrEqual(4);
-	});
-
-	it("still parses a flush fence normally (regression)", () => {
-		const text = "```ts\ncode\n```\ntext";
-		expect(fencedCodeText(text)).toBe("```ts\ncode\n```");
-	});
-
-	it("still parses a fence nested in a list item (regression)", () => {
-		const text = ["- item", "  ```js", "  code;", "  ```", "", "after"].join("\n");
-		const fence = fencedCodeText(text);
-		expect(fence).not.toBeNull();
-		expect(fence).not.toContain("after");
-	});
-
-	// Matches MDX/micromark: exactly the opening fence's indentation is removed
-	// from each content line; deeper indentation is preserved.
-	it("strips the opening fence indent from content, preserving deeper indent", () => {
-		const text =
-			"\t```ts\n\timport { Surreal } from 'surrealdb';\n\t\tconst indented = 1;\n\t```";
-		expect(fencedCodeBody(text)).toBe(
-			"import { Surreal } from 'surrealdb';\n\tconst indented = 1;",
-		);
-	});
-});

package/tests/unit/MarkdownEditor/jsx-attr-scan.test.ts

@@ -1,115 +0,0 @@
-import {
-	buildJsxTagHighlights,
-	findJsonAttributeClose,
-	parseAttributes,
-	parseJsonAttribute,
-	resolveAttributeValue,
-} from "@src/lib/markdown/grammar/html-attrs";
-import { describe, expect, it } from "vitest";
-
-describe("findJsonAttributeClose", () => {
-	it("finds the closing brace for nested JSON objects and strings", () => {
-		const json = '{"version": "2.0.0", "items": [{"id": 1}]}';
-		const full = `{${json}}`;
-		const bounds = findJsonAttributeClose(`${full} trailing`, 0);
-		expect(bounds).toEqual({
-			contentFrom: 1,
-			contentTo: full.length - 1,
-			closeBrace: full.length - 1,
-		});
-	});
-
-	it("handles braces inside JSON strings", () => {
-		const json = '{"note": "}"}';
-		const full = `{${json}}`;
-		const bounds = findJsonAttributeClose(full, 0);
-		expect(bounds?.closeBrace).toBe(full.length - 1);
-	});
-});
-
-describe("parseJsonAttribute", () => {
-	it("parses JSON literals without evaluation", () => {
-		expect(parseJsonAttribute("42")).toBe(42);
-		expect(parseJsonAttribute('"hello"')).toBe("hello");
-		expect(parseJsonAttribute('{"enabled": true}')).toEqual({ enabled: true });
-	});
-
-	it("returns undefined for invalid JSON", () => {
-		expect(parseJsonAttribute("{ foo: 1 }")).toBeUndefined();
-		expect(parseJsonAttribute("count")).toBeUndefined();
-	});
-});
-
-describe("resolveAttributeValue", () => {
-	it("resolves JSON attribute values", () => {
-		expect(resolveAttributeValue({ type: "json", value: "100" })).toBe(100);
-		expect(resolveAttributeValue({ type: "json", value: '"2.0.0"' })).toBe("2.0.0");
-	});
-});
-
-describe("buildJsxTagHighlights", () => {
-	const tag = '<Since v={"2.0.0"} t="true" b="false" />';
-
-	it("covers the attribute section without gaps for the nested HTML parser", () => {
-		const highlights = buildJsxTagHighlights(tag);
-		const attrStart = tag.indexOf(" v=");
-		const attrEnd = tag.lastIndexOf(">");
-
-		const gaps = leftoverGaps(attrStart, attrEnd, highlights);
-		expect(gaps).toEqual([]);
-	});
-
-	it("labels attribute names and quoted literals after a JSON value", () => {
-		const highlights = buildJsxTagHighlights(tag);
-		const names = textAtKinds(tag, highlights, "name");
-		const strings = textAtKinds(tag, highlights, "string");
-
-		expect(names).toEqual(["v", "t", "b"]);
-		expect(strings).toEqual(['"true"', '"false"']);
-	});
-
-	it("matches parseAttributes JSON boundaries", () => {
-		const { endIndex } = readTagNameForTest(tag);
-		const attrString = tag.slice(endIndex, tag.lastIndexOf(">"));
-		const attrs = parseAttributes(attrString);
-		const expr = buildJsxTagHighlights(tag).find((h) => h.kind === "expression-content");
-
-		expect(attrs.v).toEqual({ type: "json", value: '"2.0.0"' });
-		expect(expr).toBeDefined();
-		if (!expr) return;
-		expect(tag.slice(expr.from, expr.to)).toBe('"2.0.0"');
-		expect(attrs.t).toBe("true");
-		expect(attrs.b).toBe("false");
-	});
-});
-
-function readTagNameForTest(text: string): { endIndex: number } {
-	let i = 1;
-	while (i < text.length && !/[\s/>]/.test(text[i] ?? "")) i++;
-	return { endIndex: i };
-}
-
-function leftoverGaps(
-	from: number,
-	to: number,
-	spans: { from: number; to: number }[],
-): { from: number; to: number }[] {
-	const gaps: { from: number; to: number }[] = [];
-	let pos = from;
-
-	for (const span of spans) {
-		if (span.from > pos) gaps.push({ from: pos, to: span.from });
-		pos = Math.max(pos, span.to);
-	}
-
-	if (pos < to) gaps.push({ from: pos, to });
-	return gaps;
-}
-
-function textAtKinds(
-	text: string,
-	highlights: ReturnType<typeof buildJsxTagHighlights>,
-	kind: "name" | "string",
-): string[] {
-	return highlights.filter((h) => h.kind === kind).map((h) => text.slice(h.from, h.to));
-}

package/tests/unit/MarkdownEditor/jsx-block-widget.test.ts

@@ -1,92 +0,0 @@
-import { EditorSelection, EditorState } from "@codemirror/state";
-import { type Decoration, type DecorationSet, EditorView } from "@codemirror/view";
-import { markdownModeField, setMarkdownMode } from "@src/lib/markdown";
-import { markdownDecorations } from "@src/lib/markdown/editor/decorations";
-import { setMarkdownEditorFocused } from "@src/lib/markdown/editor/decorations/editor-focus";
-import { JsxBlockWidget } from "@src/lib/markdown/editor/widgets/jsx-widget";
-import { createWidgetStore } from "@src/lib/markdown/editor/widgets/store";
-import { Callout } from "@src/lib/markdown/grammar/callout";
-import { createMarkdownLanguage } from "@src/lib/markdown/grammar/language";
-import { afterEach, describe, expect, it } from "vitest";
-
-const views: EditorView[] = [];
-
-afterEach(() => {
-	for (const v of views.splice(0)) v.destroy();
-});
-
-/** Build a focused, preview-mode editor with the caret at `cursor`. */
-function preview(doc: string, cursor: number): EditorView {
-	const state = EditorState.create({
-		doc,
-		extensions: [
-			createMarkdownLanguage({ extensions: [Callout] }),
-			markdownModeField,
-			markdownDecorations({ widgetStore: createWidgetStore() }),
-		],
-	});
-	const parent = document.createElement("div");
-	document.body.appendChild(parent);
-	const view = new EditorView({ state, parent });
-	views.push(view);
-	view.dispatch({ effects: setMarkdownMode.of("preview") });
-	view.focus();
-	view.dispatch({ effects: setMarkdownEditorFocused.of(true) });
-	view.dispatch({ selection: EditorSelection.cursor(cursor) });
-	return view;
-}
-
-function jsxBlockRanges(view: EditorView): Array<{ from: number; to: number }> {
-	const out: Array<{ from: number; to: number }> = [];
-	for (const set of (view as unknown as { docView: { decorations: DecorationSet[] } }).docView
-		.decorations) {
-		const cursor = set.iter();
-		while (cursor.value) {
-			const widget = (cursor.value.spec as { widget?: Decoration }).widget;
-			if (widget instanceof JsxBlockWidget) {
-				out.push({ from: cursor.from, to: cursor.to });
-			}
-			cursor.next();
-		}
-	}
-	return out;
-}
-
-const TABS = `<Tabs syncKey="demo">
-<TabItem label="A">
-Alpha para one.
-
-Alpha para two.
-</TabItem>
-<TabItem label="B">
-Beta para one.
-</TabItem>
-</Tabs>`;
-
-// Some prose before the block so the caret can sit fully outside it.
-const TABS_WITH_PROSE = `Intro line.\n\n${TABS}`;
-
-describe("MarkdownEditor / JSX block widget", () => {
-	it("renders a multi-paragraph Tabs block as a single widget when the caret is outside", () => {
-		const view = preview(TABS_WITH_PROSE, 0); // caret in the intro line
-		const ranges = jsxBlockRanges(view);
-		expect(ranges).toHaveLength(1);
-		// Covers the whole <Tabs>…</Tabs> span, not a fragment of it.
-		const tabsStart = TABS_WITH_PROSE.indexOf("<Tabs");
-		expect(ranges[0]?.from).toBe(tabsStart);
-		expect(ranges[0]?.to).toBe(TABS_WITH_PROSE.length);
-	});
-
-	it("reveals the entire block as source (no partial widgets) when the caret is inside", () => {
-		// Caret inside the first tab's content.
-		const inside = TABS_WITH_PROSE.indexOf("Alpha para one.") + 3;
-		const view = preview(TABS_WITH_PROSE, inside);
-		expect(jsxBlockRanges(view)).toHaveLength(0);
-	});
-
-	it("keeps nested TabItem tags raw when the caret is on the closing tag line", () => {
-		const onClose = TABS_WITH_PROSE.indexOf("</Tabs>") + 1;
-		const view = preview(TABS_WITH_PROSE, onClose);
-		expect(jsxBlockRanges(view)).toHaveLength(0);
-	});
-});

package/tests/unit/MarkdownEditor/jsx-tag-grammar.test.ts

@@ -1,88 +0,0 @@
-import {
-	JSX_ATTR_NAME_NODE,
-	JSX_ATTR_STRING_NODE,
-	JSX_EXPRESSION_CONTENT_NODE,
-	JSX_EXPRESSION_MARK_NODE,
-} from "@src/lib/markdown/grammar/jsx-tag";
-import { createMarkdownLanguage } from "@src/lib/markdown/grammar/language";
-import { describe, expect, it } from "vitest";
-
-function parse(text: string) {
-	const support = createMarkdownLanguage({ addKeymap: false, pasteURLAsLink: false });
-	return support.language.parser.parse(text);
-}
-
-function nodeNames(text: string): string[] {
-	const tree = parse(text);
-	const names: string[] = [];
-	tree.iterate({
-		enter: (n) => {
-			names.push(n.name);
-		},
-	});
-	return names;
-}
-
-function htmlTagSpan(text: string): { from: number; to: number } | null {
-	const tree = parse(text);
-	let span: { from: number; to: number } | null = null;
-	tree.iterate({
-		enter: (n) => {
-			if (n.name === "HTMLTag") span = { from: n.from, to: n.to };
-		},
-	});
-	return span;
-}
-
-describe("JsxTag grammar extension", () => {
-	it("keeps plain quoted attributes on the built-in HTMLTag parser", () => {
-		expect(nodeNames('<Since v="1" />')).toEqual(["Document", "Paragraph", "HTMLTag"]);
-		expect(nodeNames('<Since v="1" />')).not.toContain(JSX_EXPRESSION_CONTENT_NODE);
-	});
-
-	it("parses a full HTMLTag when the attribute value is a JSX expression", () => {
-		const text = '<Component prop={"a"} />';
-		expect(htmlTagSpan(text)).toEqual({ from: 0, to: text.length });
-		expect(nodeNames(text)).toContain(JSX_EXPRESSION_CONTENT_NODE);
-		expect(nodeNames(text)).toContain(JSX_EXPRESSION_MARK_NODE);
-	});
-
-	it("does not truncate at > inside a JSX expression", () => {
-		const text = "<Component prop={foo > bar} />";
-		expect(htmlTagSpan(text)).toEqual({ from: 0, to: text.length });
-	});
-
-	it("parses multiple JSX tags on one line", () => {
-		const text = '<Tabs defaultValue={"a"}><TabItem label={x} /></Tabs>';
-		const tree = parse(text);
-		const tags: string[] = [];
-		tree.iterate({
-			enter: (n) => {
-				if (n.name === "HTMLTag") tags.push(text.slice(n.from, n.to));
-			},
-		});
-		expect(tags).toEqual(['<Tabs defaultValue={"a"}>', "<TabItem label={x} />", "</Tabs>"]);
-	});
-
-	it("highlights quoted attributes that follow a JSX expression", () => {
-		const text = '<Since v={"2.0.0"} t="true" b="false" />';
-		expect(htmlTagSpan(text)).toEqual({ from: 0, to: text.length });
-
-		const tree = parse(text);
-		const names = collectNodes(tree, text, JSX_ATTR_NAME_NODE);
-		const strings = collectNodes(tree, text, JSX_ATTR_STRING_NODE);
-
-		expect(names).toEqual(["v", "t", "b"]);
-		expect(strings).toEqual(['"true"', '"false"']);
-	});
-});
-
-function collectNodes(tree: ReturnType<typeof parse>, text: string, name: string): string[] {
-	const out: string[] = [];
-	tree.iterate({
-		enter: (n) => {
-			if (n.name === name) out.push(text.slice(n.from, n.to));
-		},
-	});
-	return out;
-}

package/tests/unit/MarkdownEditor/list-indent.test.ts

@@ -1,95 +0,0 @@
-import { EditorSelection, EditorState } from "@codemirror/state";
-import { EditorView } from "@codemirror/view";
-import { indentMarkdownList } from "@src/lib/markdown/editor/list-indent";
-import { Callout } from "@src/lib/markdown/grammar/callout";
-import { createMarkdownLanguage } from "@src/lib/markdown/grammar/language";
-import { afterEach, describe, expect, it } from "vitest";
-
-let view: EditorView;
-
-afterEach(() => {
-	view?.destroy();
-});
-
-function createView(doc: string, cursor: number): EditorView {
-	const state = EditorState.create({
-		doc,
-		selection: EditorSelection.cursor(cursor),
-		extensions: [createMarkdownLanguage({ extensions: [Callout] })],
-	});
-	const parent = document.createElement("div");
-	document.body.appendChild(parent);
-	view = new EditorView({ state, parent });
-	return view;
-}
-
-/** Index just after the marker + space of the line containing `needle`. */
-function cursorInItem(doc: string, needle: string): number {
-	return doc.indexOf(needle) + 1;
-}
-
-describe("indentMarkdownList", () => {
-	it("indents an item under its preceding sibling", () => {
-		const doc = "- one\n- two";
-		const v = createView(doc, cursorInItem(doc, "two"));
-		const handled = indentMarkdownList(v, false);
-		expect(handled).toBe(true);
-		expect(v.state.doc.toString()).toBe("- one\n  - two");
-	});
-
-	it("consumes Tab but does not change the first item (no preceding sibling)", () => {
-		const doc = "- one\n- two";
-		const v = createView(doc, cursorInItem(doc, "one"));
-		const handled = indentMarkdownList(v, false);
-		expect(handled).toBe(true);
-		expect(v.state.doc.toString()).toBe(doc);
-	});
-
-	it("outdents a nested item to its parent level", () => {
-		const doc = "- one\n  - two";
-		const v = createView(doc, cursorInItem(doc, "two"));
-		const handled = indentMarkdownList(v, true);
-		expect(handled).toBe(true);
-		expect(v.state.doc.toString()).toBe("- one\n- two");
-	});
-
-	it("consumes Shift-Tab but does not outdent a top-level item", () => {
-		const doc = "- one\n- two";
-		const v = createView(doc, cursorInItem(doc, "two"));
-		const handled = indentMarkdownList(v, true);
-		expect(handled).toBe(true);
-		expect(v.state.doc.toString()).toBe(doc);
-	});
-
-	it("returns false outside a list", () => {
-		const doc = "just a paragraph";
-		const v = createView(doc, 4);
-		expect(indentMarkdownList(v, false)).toBe(false);
-		expect(indentMarkdownList(v, true)).toBe(false);
-	});
-
-	it("indents ordered list items by the marker width", () => {
-		const doc = "1. one\n2. two";
-		const v = createView(doc, cursorInItem(doc, "two"));
-		const handled = indentMarkdownList(v, false);
-		expect(handled).toBe(true);
-		expect(v.state.doc.toString()).toBe("1. one\n   2. two");
-	});
-
-	it("indents an item together with its nested children", () => {
-		const doc = "- one\n- two\n  - child";
-		const v = createView(doc, cursorInItem(doc, "two"));
-		const handled = indentMarkdownList(v, false);
-		expect(handled).toBe(true);
-		expect(v.state.doc.toString()).toBe("- one\n  - two\n    - child");
-	});
-
-	it("keeps the cursor with the indented text", () => {
-		const doc = "- one\n- two";
-		const start = doc.indexOf("two");
-		const v = createView(doc, start);
-		indentMarkdownList(v, false);
-		// Two spaces inserted before the line shift the cursor right by two.
-		expect(v.state.selection.main.head).toBe(start + 2);
-	});
-});