@octane-xplat/ui 0.9.0 → 0.11.0

package/dist/web/markdown-parse.js

@@ -0,0 +1,342 @@
+//#region src/markdown-parse.ts
+var FENCE = /^ {0,3}(`{3,}|~{3,})[ \t]*(.*)$/;
+var FENCE_CLOSE = /^ {0,3}(`{3,}|~{3,})[ \t]*$/;
+var ATX = /^ {0,3}(#{1,6})(?:[ \t]+(.*?))?[ \t]*$/;
+var SETEXT_H1 = /^ {0,3}=+[ \t]*$/;
+var SETEXT_H2 = /^ {0,3}-+[ \t]*$/;
+var HR = /^ {0,3}(?:\*[ \t]*){3,}$|^ {0,3}(?:-[ \t]*){3,}$|^ {0,3}(?:_[ \t]*){3,}$/;
+var QUOTE = /^ {0,3}>[ \t]?/;
+var ITEM = /^ {0,3}([-*+]|\d{1,9}[.)])([ \t]+)(.*)$/;
+var BLANK = /^\s*$/;
+/** A list's CommonMark continuation key: bullet character for unordered
+*  (`-`,`*`,`+`), delimiter for ordered (`.`,`)`). Items separated by blank
+*  lines stay in one list only while the mark matches. */
+function listMark(m) {
+	return /^\d/.test(m[1]) ? m[1].slice(-1) : m[1];
+}
+/** Does this line start a new block? Mirrors the tests in parseBlocks — a
+*  missed case makes the paragraph collector swallow a block opener. */
+function isBlockStart(line) {
+	return FENCE.test(line) || ATX.test(line) || HR.test(line) || QUOTE.test(line) || ITEM.test(line);
+}
+function parseBlocks(source) {
+	const nodes = [];
+	const marks = [];
+	const lines = source.split("\n");
+	let i = 0;
+	while (i < lines.length) {
+		const line = lines[i];
+		if (BLANK.test(line)) {
+			i++;
+			continue;
+		}
+		const fence = line.match(FENCE);
+		if (fence) {
+			const marker = fence[1];
+			const lang = fence[2].trim().split(/\s+/)[0] || void 0;
+			const buf = [];
+			i++;
+			while (i < lines.length) {
+				const close = lines[i].match(FENCE_CLOSE);
+				if (close && close[1][0] === marker[0] && close[1].length >= marker.length) {
+					i++;
+					break;
+				}
+				buf.push(lines[i]);
+				i++;
+			}
+			nodes.push({
+				t: "code",
+				lang,
+				text: buf.join("\n")
+			});
+			marks.push(void 0);
+			continue;
+		}
+		const heading = line.match(ATX);
+		if (heading) {
+			const text = (heading[2] ?? "").replace(/[ \t]+#+$/, "");
+			nodes.push({
+				t: "h",
+				depth: heading[1].length,
+				children: parseMdInline(text)
+			});
+			marks.push(void 0);
+			i++;
+			continue;
+		}
+		if (HR.test(line)) {
+			nodes.push({ t: "hr" });
+			marks.push(void 0);
+			i++;
+			continue;
+		}
+		const firstItem = line.match(ITEM);
+		if (firstItem) {
+			const ordered = /^\d/.test(firstItem[1]);
+			const mark = listMark(firstItem);
+			const items = [];
+			while (i < lines.length) {
+				const it = lines[i].match(ITEM);
+				if (!it || /^\d/.test(it[1]) !== ordered || listMark(it) !== mark) break;
+				const parts = [it[3]];
+				i++;
+				while (i < lines.length && /^ {2,}\S/.test(lines[i]) && !isBlockStart(lines[i].trimStart())) {
+					parts.push(lines[i].trim());
+					i++;
+				}
+				items.push(parseMdInline(parts.join("\n")));
+				const save = i;
+				while (i < lines.length && BLANK.test(lines[i])) i++;
+				const next = i < lines.length ? lines[i].match(ITEM) : null;
+				if (!next || /^\d/.test(next[1]) !== ordered || listMark(next) !== mark) {
+					i = save;
+					break;
+				}
+			}
+			nodes.push({
+				t: "list",
+				ordered,
+				items
+			});
+			marks.push(mark);
+			continue;
+		}
+		if (QUOTE.test(line)) {
+			const buf = [];
+			while (i < lines.length && QUOTE.test(lines[i])) {
+				buf.push(lines[i].replace(QUOTE, ""));
+				i++;
+			}
+			nodes.push({
+				t: "quote",
+				children: parseMdInline(buf.join("\n"))
+			});
+			marks.push(void 0);
+			continue;
+		}
+		const buf = [];
+		while (i < lines.length && !BLANK.test(lines[i])) {
+			const l = lines[i];
+			if (buf.length > 0 && (SETEXT_H1.test(l) || SETEXT_H2.test(l))) {
+				nodes.push({
+					t: "h",
+					depth: SETEXT_H1.test(l) ? 1 : 2,
+					children: parseMdInline(buf.join("\n"))
+				});
+				marks.push(void 0);
+				buf.length = 0;
+				i++;
+				break;
+			}
+			if (buf.length > 0 && isBlockStart(l)) break;
+			buf.push(l);
+			i++;
+		}
+		if (buf.length > 0) {
+			nodes.push({
+				t: "p",
+				children: parseMdInline(buf.join("\n"))
+			});
+			marks.push(void 0);
+		}
+	}
+	return {
+		nodes,
+		marks
+	};
+}
+/** Parse Markdown source into the renderer's block AST. */
+function parseMdNodes(source) {
+	return parseBlocks(source).nodes;
+}
+/** Parse Markdown source into a `Markdown`-renderable doc — the runtime
+*  counterpart of the codegen's baked `MdDoc`. */
+function parseMdDoc(source) {
+	return {
+		kind: "octane-xplat/md",
+		v: 1,
+		children: parseMdNodes(source)
+	};
+}
+/** Same parse as `parseMdNodes` plus per-node list continuation keys.
+*  Internal — the incremental parser needs marks to merge loose lists split
+*  across its settled/delta seam. */
+function parseMdNodesMarked(source) {
+	const { nodes, marks } = parseBlocks(source);
+	return {
+		nodes,
+		listMarks: marks
+	};
+}
+/** Flatten inline nodes to their visible text — the runtime counterpart of
+*  codegen's `inlineText` (link labels drop nested formatting). */
+function mdInlineText(nodes) {
+	let out = "";
+	for (const n of nodes) switch (n.t) {
+		case "bold":
+		case "em":
+			out += mdInlineText(n.children);
+			break;
+		case "link":
+			out += n.text;
+			break;
+		default: out += n.text;
+	}
+	return out;
+}
+/** Rendered length of an inline run — `mdInlineText` without allocating. */
+function mdInlineLen(nodes) {
+	let n = 0;
+	for (const node of nodes) switch (node.t) {
+		case "bold":
+		case "em":
+			n += mdInlineLen(node.children);
+			break;
+		default: n += node.text.length;
+	}
+	return n;
+}
+var ESCAPABLE = /[!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~]/;
+/** Unicode letter-or-number test for the intraword `_` rule. Unicode
+*  property escapes (`\\p{L}`, `\\p{N}`) need Unicode tables — a regex
+*  literal on an engine without them throws SyntaxError at parse time and
+*  poisons the whole bundle (this is how NativeScript's embedded V8
+*  ships). check-native-dist scans emitted comments too, so keep the
+*  double-backslash spelling here. Build the pattern dynamically instead:
+*  general categories where full Unicode exists, the spec-required minimal
+*  property set otherwise, ASCII as a last resort. */
+var WORD_CHAR = (() => {
+	for (const pattern of ["[\\p{L}\\p{N}]", "[\\p{ID_Start}\\p{ID_Continue}]"]) try {
+		return new RegExp(pattern, "u");
+	} catch {}
+	return /[A-Za-z0-9]/;
+})();
+/** Scan a run of `ch` starting at `i`. */
+function runLen(text, i, ch) {
+	let n = 0;
+	while (text[i + n] === ch) n++;
+	return n;
+}
+/** Find the closing index for a `len`-marker emphasis starting at `from`, or
+*  -1. `_`/`__` additionally refuses intraword matches (an alphanumeric on
+*  both sides), matching CommonMark's flanking rule loosely. */
+function findEmClose(text, from, marker) {
+	return text.indexOf(marker, from);
+}
+function parseMdInline(text) {
+	const nodes = [];
+	let buf = "";
+	let i = 0;
+	const flush = () => {
+		if (buf) {
+			nodes.push({
+				t: "text",
+				text: buf
+			});
+			buf = "";
+		}
+	};
+	while (i < text.length) {
+		const ch = text[i];
+		if (ch === "\\" && i + 1 < text.length && ESCAPABLE.test(text[i + 1])) {
+			buf += text[i + 1];
+			i += 2;
+			continue;
+		}
+		if (ch === "`") {
+			const n = runLen(text, i, "`");
+			const close = text.indexOf("`".repeat(n), i + n);
+			if (close !== -1 && close > i + n) {
+				flush();
+				nodes.push({
+					t: "code",
+					text: text.slice(i + n, close)
+				});
+				i = close + n;
+				continue;
+			}
+			buf += "`".repeat(n);
+			i += n;
+			continue;
+		}
+		if (ch === "*" || ch === "_") {
+			const n = runLen(text, i, ch);
+			const marker = ch.repeat(n);
+			const wordBefore = i > 0 && WORD_CHAR.test(text[i - 1]);
+			if (ch === "_" && wordBefore) {
+				buf += marker;
+				i += n;
+				continue;
+			}
+			let matched = false;
+			for (let len = Math.min(n, 3); len >= 1 && !matched; len--) {
+				const m = ch.repeat(len);
+				const close = findEmClose(text, i + len, m);
+				if (close === -1 || close === i + len) continue;
+				const inner = text.slice(i + len, close);
+				flush();
+				if (len === 3) nodes.push({
+					t: "bold",
+					children: [{
+						t: "em",
+						children: parseMdInline(inner)
+					}]
+				});
+				else if (len === 2) nodes.push({
+					t: "bold",
+					children: parseMdInline(inner)
+				});
+				else nodes.push({
+					t: "em",
+					children: parseMdInline(inner)
+				});
+				matched = true;
+				i = close + len;
+			}
+			if (matched) continue;
+			buf += marker;
+			i += n;
+			continue;
+		}
+		if (ch === "!" && text[i + 1] === "[") {
+			const mid = text.indexOf("](", i + 2);
+			const close = mid === -1 ? -1 : text.indexOf(")", mid + 2);
+			if (close !== -1) {
+				flush();
+				nodes.push({
+					t: "text",
+					text: text.slice(i + 2, mid)
+				});
+				i = close + 1;
+				continue;
+			}
+			buf += ch;
+			i++;
+			continue;
+		}
+		if (ch === "[") {
+			const mid = text.indexOf("](", i + 1);
+			const close = mid === -1 ? -1 : text.indexOf(")", mid + 2);
+			if (close !== -1) {
+				flush();
+				nodes.push({
+					t: "link",
+					text: mdInlineText(parseMdInline(text.slice(i + 1, mid))),
+					href: text.slice(mid + 2, close)
+				});
+				i = close + 1;
+				continue;
+			}
+			buf += ch;
+			i++;
+			continue;
+		}
+		buf += ch;
+		i++;
+	}
+	flush();
+	return nodes;
+}
+//#endregion
+export { WORD_CHAR, mdInlineLen, mdInlineText, parseMdDoc, parseMdInline, parseMdNodes, parseMdNodesMarked };

package/dist/web/markdown-stream.js

@@ -0,0 +1,264 @@
+import { WORD_CHAR, mdInlineLen, parseMdNodesMarked } from "./markdown-parse.js";
+//#region src/markdown-stream.ts
+function createMarkdownIncrementalState() {
+	return {
+		input: "",
+		settledSource: "",
+		settled: [],
+		marks: [],
+		output: []
+	};
+}
+var FENCE_OPEN = /^(`{3,}|~{3,})/;
+/**
+* Line index of the last blank line that is not inside a fenced code block —
+* the offset where the immutable prefix ends. A trailing blank line does not
+* count: it may be mid-append. An open fence collapses the boundary to the
+* blank line before it opened, since fenced content can't change what came
+* before.
+*/
+function findSettledBoundary(lines) {
+	let inFence = false;
+	let fenceMarker = "";
+	let lastBoundary = -1;
+	let boundaryBeforeFence = -1;
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		const fenceMatch = line.match(FENCE_OPEN);
+		if (inFence) {
+			if (fenceMatch && fenceMatch[1][0] === fenceMarker[0] && fenceMatch[1].length >= fenceMarker.length) {
+				inFence = false;
+				fenceMarker = "";
+			}
+			continue;
+		}
+		if (fenceMatch) {
+			inFence = true;
+			fenceMarker = fenceMatch[1];
+			boundaryBeforeFence = lastBoundary;
+			continue;
+		}
+		if (line.trim() === "" && i > 0 && i < lines.length - 1) lastBoundary = i;
+	}
+	return {
+		boundary: inFence ? boundaryBeforeFence : lastBoundary,
+		openFence: inFence
+	};
+}
+/**
+* Strip trailing incomplete inline syntax from the last line so half-typed
+* constructs don't render as literal markup: an unclosed `[`/`![` (link or
+* image), a trailing unclosed backtick run, and unpaired `*`/`_` emphasis
+* markers. Mid-line unclosed emphasis is auto-closed instead of trimmed, so
+* `**partial` renders bold immediately rather than flashing raw asterisks.
+*/
+function trimStreamingArtifacts(input) {
+	const lastNL = input.lastIndexOf("\n");
+	const prefix = lastNL === -1 ? "" : input.slice(0, lastNL + 1);
+	let tail = lastNL === -1 ? input : input.slice(lastNL + 1);
+	const lastBracket = tail.lastIndexOf("[");
+	if (lastBracket !== -1) {
+		const after = tail.slice(lastBracket);
+		if (!(after.includes("](") && after.includes(")"))) {
+			const trimTo = lastBracket > 0 && tail[lastBracket - 1] === "!" ? lastBracket - 1 : lastBracket;
+			tail = tail.slice(0, trimTo);
+		}
+	}
+	let end = tail.length;
+	while (end > 0 && tail[end - 1] === "`") end--;
+	if (end === 0 && tail.length > 0) tail = "";
+	else if (end < tail.length) {
+		const ticks = tail.length - end;
+		if (tail.lastIndexOf("`".repeat(ticks), end - 1) === -1) tail = tail.slice(0, end);
+	}
+	{
+		const markers = [];
+		let scan = 0;
+		while (scan < tail.length) {
+			const idx1 = tail.indexOf("*", scan);
+			const idx2 = tail.indexOf("_", scan);
+			const idx = idx1 === -1 ? idx2 : idx2 === -1 ? idx1 : Math.min(idx1, idx2);
+			if (idx === -1) break;
+			const ch = tail[idx];
+			let len = 0;
+			while (tail[idx + len] === ch) len++;
+			scan = idx + len;
+			if (len > 3) continue;
+			if (ch === "_" && idx > 0 && WORD_CHAR.test(tail[idx - 1])) continue;
+			markers.push({
+				pos: idx,
+				len
+			});
+		}
+		const paired = /* @__PURE__ */ new Set();
+		for (let a = 0; a < markers.length; a++) {
+			if (paired.has(a)) continue;
+			for (let b = a + 1; b < markers.length; b++) if (!paired.has(b) && markers[b].len === markers[a].len && tail[markers[b].pos] === tail[markers[a].pos]) {
+				paired.add(a);
+				paired.add(b);
+				break;
+			}
+		}
+		for (let k = markers.length - 1; k >= 0; k--) {
+			if (paired.has(k)) continue;
+			const m = markers[k];
+			if (m.pos + m.len < tail.length) tail += tail[m.pos].repeat(m.len);
+			else tail = tail.slice(0, m.pos);
+		}
+	}
+	return prefix + tail;
+}
+/**
+* Withhold trailing lines in the unsettled zone that look like the start of
+* a block but are incomplete: bare list markers (`- `, `1. `) with no item
+* text and trailing empty lines. Skipped entirely while a code fence is
+* open — inside a fence a `- ` is literal code.
+*/
+function trimUnsettledStructural(text) {
+	const lines = text.split("\n");
+	while (lines.length > 0) {
+		const last = lines[lines.length - 1];
+		if (last.trim() === "") {
+			lines.pop();
+			continue;
+		}
+		if (/^ {0,9}[-*+] ?$/.test(last) || /^ {0,9}\d+[.)] ?$/.test(last)) {
+			lines.pop();
+			continue;
+		}
+		if (/^ {0,3}> ?$/.test(last) || /^ {0,3}#{1,6} ?$/.test(last)) {
+			lines.pop();
+			continue;
+		}
+		break;
+	}
+	return lines.join("\n");
+}
+/**
+* Parse one cumulative snapshot of a streaming Markdown doc. Settled
+* blocks (everything before the last safe blank line) parse once and are
+* shared by reference between calls; only the open tail reparses. Incomplete
+* trailing constructs are withheld or auto-closed, so intermediate output
+* shows no raw markup — and once the input stops growing, the result equals
+* `parseMdNodes` on the final text.
+*
+* Non-append input (a different doc, an edit) resets the cache and
+* reparses whole.
+*/
+function parseMarkdownIncremental(input, state) {
+	if (input === state.input) return state.output;
+	if (!input.startsWith(state.settledSource)) {
+		state.settledSource = "";
+		state.settled = [];
+		state.marks = [];
+	}
+	const trimmedInput = trimStreamingArtifacts(input);
+	const tailLines = trimmedInput.slice(state.settledSource.length).split("\n");
+	const { boundary, openFence } = findSettledBoundary(tailLines);
+	const settledDelta = boundary >= 0 ? tailLines.slice(0, boundary).join("\n") : "";
+	if (settledDelta !== "") {
+		const { nodes, listMarks } = parseMdNodesMarked(settledDelta);
+		const last = state.settled[state.settled.length - 1];
+		const first = nodes[0];
+		if (last?.t === "list" && first?.t === "list" && last.ordered === first.ordered && state.marks[state.marks.length - 1] === listMarks[0]) {
+			state.settled[state.settled.length - 1] = {
+				t: "list",
+				ordered: last.ordered,
+				items: [...last.items, ...first.items]
+			};
+			state.settled.push(...nodes.slice(1));
+			state.marks.push(...listMarks.slice(1));
+		} else {
+			state.settled.push(...nodes);
+			state.marks.push(...listMarks);
+		}
+		state.settledSource += settledDelta;
+	}
+	const unsettledRaw = trimmedInput.slice(state.settledSource.length).trim();
+	const unsettled = openFence ? unsettledRaw : trimUnsettledStructural(unsettledRaw);
+	const parsed = unsettled === "" ? {
+		nodes: [],
+		listMarks: []
+	} : parseMdNodesMarked(unsettled);
+	const last = state.settled[state.settled.length - 1];
+	const first = parsed.nodes[0];
+	if (last?.t === "list" && first?.t === "list" && last.ordered === first.ordered && state.marks[state.marks.length - 1] === parsed.listMarks[0]) state.output = [
+		...state.settled.slice(0, -1),
+		{
+			t: "list",
+			ordered: last.ordered,
+			items: [...last.items, ...first.items]
+		},
+		...parsed.nodes.slice(1)
+	];
+	else state.output = [...state.settled, ...parsed.nodes];
+	state.input = input;
+	return state.output;
+}
+/**
+* Push the previous rendered length onto the boundary ring when output grew.
+* The ring caps at `maxSpans`; evicted boundaries merge into settled text.
+*/
+function computeBoundaries(prevBoundaries, prevRenderedLen, maxSpans) {
+	if (prevBoundaries.length === 0 || prevRenderedLen > prevBoundaries[prevBoundaries.length - 1]) {
+		const next = [...prevBoundaries, prevRenderedLen];
+		while (next.length > maxSpans) next.shift();
+		return next;
+	}
+	return prevBoundaries;
+}
+/**
+* Split one text run at the stream boundaries it crosses. Returns null when
+* the whole run is settled (no splitting needed). Segment keys never change
+* once created — `settled-{nodeKey}` for pre-boundary text and
+* `fade-{nodeKey}-b{offset}` per boundary span — so a fading span stays
+* mounted until it merges into the settled segment.
+*/
+function computeSegments(content, startOffset, boundaries, nodeKey) {
+	const endOffset = startOffset + content.length;
+	if (boundaries.length === 0 || endOffset <= boundaries[0]) return null;
+	const segments = [];
+	let pos = startOffset;
+	if (pos < boundaries[0]) {
+		segments.push({
+			key: `settled-${nodeKey}`,
+			text: content.slice(0, boundaries[0] - startOffset),
+			fading: false
+		});
+		pos = boundaries[0];
+	}
+	for (let i = 0; i < boundaries.length; i++) {
+		const bStart = boundaries[i];
+		const bEnd = i + 1 < boundaries.length ? boundaries[i + 1] : endOffset;
+		if (bStart >= endOffset || bEnd <= pos) continue;
+		const lo = Math.max(bStart, pos);
+		const hi = Math.min(bEnd, endOffset);
+		if (lo >= hi) continue;
+		segments.push({
+			key: `fade-${nodeKey}-b${bStart}`,
+			text: content.slice(lo - startOffset, hi - startOffset),
+			fading: true
+		});
+		pos = hi;
+	}
+	return segments.length > 0 ? segments : null;
+}
+/** Total rendered text length of a node list — the cursor metric fade
+*  boundaries are computed against. */
+function markdownTextLength(nodes) {
+	let n = 0;
+	for (const node of nodes) switch (node.t) {
+		case "h":
+		case "p":
+		case "quote":
+			n += mdInlineLen(node.children);
+			break;
+		case "code":
+			n += node.text.length;
+			break;
+		case "list": for (const item of node.items) n += mdInlineLen(item);
+	}
+	return n;
+}
+//#endregion
+export { computeBoundaries, computeSegments, createMarkdownIncrementalState, markdownTextLength, parseMarkdownIncremental, trimStreamingArtifacts };

package/dist/web/menu-context.js

@@ -0,0 +1,11 @@
+import { createContext, useContext } from "octane";
+//#region src/menu-context.ts
+var DropdownMenuContext = /* @__PURE__ */ createContext(null);
+var MenuProvider = DropdownMenuContext;
+function useDropdownMenuContext() {
+	return useContext(DropdownMenuContext);
+}
+var MenuRadioContext = /* @__PURE__ */ createContext(null);
+var MenuRadioProvider = MenuRadioContext;
+//#endregion
+export { DropdownMenuContext, MenuProvider, MenuRadioContext, MenuRadioProvider, useDropdownMenuContext };

package/dist/web/metadata-list-context.js

@@ -0,0 +1,6 @@
+import { createContext } from "octane";
+//#region src/metadata-list-context.ts
+var MetadataListContext = /* @__PURE__ */ createContext(null);
+var MetadataListProvider = MetadataListContext;
+//#endregion
+export { MetadataListContext, MetadataListProvider };