@surrealdb/ui 1.2.15 → 1.2.16

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@surrealdb/ui",
-	"version": "1.2.15",
+	"version": "1.2.16",
 	"type": "module",
 	"sideEffects": false,
 	"exports": {

package/release-notes.md

@@ -0,0 +1,39 @@
+Fenced code blocks tagged `tsx` or `jsx` rendered as plain, unhighlighted text in both the markdown viewer and the editor, and TypeScript blocks were silently parsed as plain JavaScript.
+
+## Cause
+
+`src/syntax/language.ts` mapped both `javascript` and `typescript` to the bare `@lezer/javascript` parser. That grammar exposes `dialects: {jsx, ts}`, but Lezer dialects are opt-in and nothing configured them.
+
+Two consequences:
+
+- `tsx` and `jsx` were not registered as languages or aliases. `findLanguageDefinition` returned `null`, so `MarkdownCodeLines` fell back to rendering each line as a bare fragment, `createMarkdownLanguage` skipped embedded highlighting in the editor, and neither appeared in the fence language picker.
+- `ts` resolved, but to a JavaScript grammar. Type annotations and `interface` declarations parsed as errors.
+
+Measured against the installed parser:
+
+```
+### ts (interface + annotations)
+   bare parser (before)   error nodes: 2
+   dialect: ts            error nodes: 0
+### tsx (JSX element)
+   bare parser (before)   error nodes: 4
+   dialect: ts            error nodes: 2
+   dialect: jsx ts        error nodes: 0
+```
+
+## Change
+
+- `javascript` now uses `dialect: "jsx"` and gains the `jsx` alias.
+- `typescript` now uses `dialect: "jsx ts"` and gains the `tsx` alias.
+
+Registering them as aliases rather than separate entries keeps the exported `Language` union and the fence language picker unchanged.
+
+Enabling `jsx` on plain JavaScript is safe. The grammar only treats `<` as a tag start where an expression may begin, so comparisons, generic calls, and shift operators parse with zero errors before and after.
+
+## Tests
+
+Adds `tests/unit/Syntax/language.test.ts` covering registration, alias resolution, JSX and TypeScript parsing, and a regression guard that plain JavaScript comparison and shift operators are not read as JSX. Four of the five fail without the fix. Full unit suite passes at 274 tests, and the library builds.
+
+## Impact
+
+Consumers get highlighting for `tsx` and `jsx` blocks, and correct highlighting for the `ts` blocks they already have. On docs.surrealdb.com that is 23 `tsx` and 2 `jsx` blocks currently unhighlighted, plus roughly 1,150 `ts` blocks that were being parsed as JavaScript.

package/tests/unit/Syntax/language.test.ts

@@ -0,0 +1,63 @@
+import { getLanguageName, getLanguageParser } from "@src/syntax/language";
+import { describe, expect, it } from "vitest";
+
+/**
+ * Counts the error nodes a registered language produces for a source snippet.
+ * A clean parse is the prerequisite for any highlighting at all, so this is
+ * the cheapest signal that a grammar is configured for the syntax it claims
+ * to support.
+ */
+function errorCount(language: string, source: string): number {
+	const parser = getLanguageParser(language);
+
+	if (!parser) {
+		throw new Error(`No parser registered for "${language}"`);
+	}
+
+	let errors = 0;
+
+	parser.parse(source).iterate({
+		enter: (node) => {
+			if (node.type.isError) errors++;
+		},
+	});
+
+	return errors;
+}
+
+const TSX_SOURCE = `export function Greeting({ name }: { name: string }) {
+	return <View><Text>{name}</Text></View>;
+}`;
+
+const TS_SOURCE = `interface User { id: string; age?: number }
+const user: User = { id: "a" };`;
+
+const JS_SOURCE = `const ok = a < b && c > d;
+const shifted = (n) => n << 2 > 1;`;
+
+describe("language registry", () => {
+	it("registers tsx and jsx", () => {
+		expect(getLanguageParser("tsx")).toBeDefined();
+		expect(getLanguageParser("jsx")).toBeDefined();
+	});
+
+	it("resolves tsx and jsx to their base language names", () => {
+		expect(getLanguageName("tsx")).toBe("TypeScript");
+		expect(getLanguageName("jsx")).toBe("JavaScript");
+	});
+
+	it("parses JSX under jsx and tsx", () => {
+		expect(errorCount("jsx", "const a = <View><Text>hi</Text></View>;")).toBe(0);
+		expect(errorCount("tsx", TSX_SOURCE)).toBe(0);
+	});
+
+	it("parses TypeScript syntax under ts and tsx", () => {
+		expect(errorCount("ts", TS_SOURCE)).toBe(0);
+		expect(errorCount("tsx", TS_SOURCE)).toBe(0);
+	});
+
+	it("does not misread comparison operators as JSX in plain JavaScript", () => {
+		expect(errorCount("js", JS_SOURCE)).toBe(0);
+		expect(errorCount("ts", JS_SOURCE)).toBe(0);
+	});
+});