@jigs.design/compiler 0.0.0-stage → 0.1.1

package/dist/parse.js

@@ -0,0 +1,690 @@
+import { extendMap, sliceMap, sourceOffset, sourceRange } from "./offsets.js";
+//#region src/parse.ts
+const TAG_NAME = /[A-Za-z][\w-]*/y;
+const ATTR_NAME = /[A-Za-z_][\w-]*/y;
+const QUOTES = /* @__PURE__ */ new Set([
+	"\"",
+	"'",
+	"`"
+]);
+const isSpace = (char) => /\s/.test(char);
+function matchAt(pattern, source, index) {
+	pattern.lastIndex = index;
+	return pattern.exec(source)?.[0] ?? null;
+}
+function skipSpace(source, index) {
+	let cursor = index;
+	while (cursor < source.length && isSpace(source.charAt(cursor))) cursor++;
+	return cursor;
+}
+/** Code in braces that is only comments, such as `{/* note *\/}`. */
+const ONLY_COMMENTS = /^(?:\s|\/\/[^\n]*|\/\*[\s\S]*?\*\/)*$/;
+/**
+* Index of the `}` in a line comment that closes the outermost brace, as in
+* `{@body const total = 3 // it's the total}`, or -1. Braces the comment opens
+* itself, as in `// sort by {value}`, are its own text.
+*/
+function commentCloser(source, start, end) {
+	let depth = 0;
+	for (let index = start; index < end; index++) {
+		const char = source.charAt(index);
+		if (char === "{") depth++;
+		else if (char === "}") {
+			depth--;
+			if (depth < 0) return index;
+		}
+	}
+	return -1;
+}
+/**
+* Index just past the `}` matching the `{` at `start`, or -1 if unbalanced.
+* Quotes inside comments don't open strings. A line comment ends at its
+* newline, or at an unmatched `}` that closes the outermost brace (see
+* `commentCloser`).
+*/
+function scanBalanced(source, start) {
+	let depth = 0;
+	let quote = null;
+	for (let index = start; index < source.length; index++) {
+		const char = source.charAt(index);
+		if (quote !== null) {
+			if (char === "\\") index++;
+			else if (char === quote) quote = null;
+			continue;
+		}
+		if (char === "/" && source.charAt(index + 1) === "/") {
+			const newline = source.indexOf("\n", index);
+			const lineEnd = newline === -1 ? source.length : newline;
+			const closer = depth === 1 ? commentCloser(source, index + 2, lineEnd) : -1;
+			if (closer !== -1) return closer + 1;
+			index = lineEnd - 1;
+			continue;
+		}
+		if (char === "/" && source.charAt(index + 1) === "*") {
+			const end = source.indexOf("*/", index + 2);
+			if (end === -1) return -1;
+			index = end + 1;
+			continue;
+		}
+		if (QUOTES.has(char)) quote = char;
+		else if (char === "{") depth++;
+		else if (char === "}") {
+			depth--;
+			if (depth === 0) return index + 1;
+		}
+	}
+	return -1;
+}
+/** The code between `from` and `to`, trimmed, as a prop value. */
+function readBraced(source, from, to, map) {
+	const code = source.slice(from, to);
+	const trimmed = code.trim();
+	if (trimmed === "") return null;
+	if (/^-?\d+(?:\.\d+)?$/.test(trimmed)) return {
+		kind: "literal",
+		value: Number(trimmed)
+	};
+	if (trimmed === "true" || trimmed === "false") return {
+		kind: "literal",
+		value: trimmed === "true"
+	};
+	const quoted = /^"([^"\\]*)"$|^'([^'\\]*)'$/.exec(trimmed);
+	if (quoted) return {
+		kind: "literal",
+		value: quoted[1] ?? quoted[2] ?? ""
+	};
+	return {
+		at: sliceMap(map, from + code.length - code.trimStart().length),
+		code: trimmed,
+		kind: "expr"
+	};
+}
+/** `map` gives the source offsets of `source`, for the tag's props. */
+function scanOpenTag(source, start, map) {
+	const name = matchAt(TAG_NAME, source, start + 1);
+	if (name === null) return "invalid";
+	const props = [];
+	let cursor = start + 1 + name.length;
+	for (;;) {
+		cursor = skipSpace(source, cursor);
+		if (cursor >= source.length) return "incomplete";
+		if (source.startsWith("/>", cursor) || source.charAt(cursor) === ">") {
+			const selfClosing = source.charAt(cursor) === "/";
+			const end = cursor + (selfClosing ? 2 : 1);
+			const range = sourceRange(map, start, end);
+			return {
+				end,
+				token: {
+					end: range.end,
+					name,
+					props,
+					selfClosing,
+					start: range.start,
+					type: "open"
+				}
+			};
+		}
+		if (source.charAt(cursor) === "/" && cursor + 1 >= source.length) return "incomplete";
+		const attr = matchAt(ATTR_NAME, source, cursor);
+		if (attr === null) return "invalid";
+		const attrStart = cursor;
+		cursor = skipSpace(source, cursor + attr.length);
+		if (source.charAt(cursor) !== "=") {
+			const range = sourceRange(map, attrStart, attrStart + attr.length);
+			props.push({
+				end: range.end,
+				name: attr,
+				shorthand: true,
+				start: range.start,
+				value: {
+					kind: "literal",
+					value: true
+				}
+			});
+			continue;
+		}
+		cursor = skipSpace(source, cursor + 1);
+		const opener = source.charAt(cursor);
+		if (opener === "") return "incomplete";
+		if (opener === "\"" || opener === "'") {
+			const close = source.indexOf(opener, cursor + 1);
+			if (close === -1) return "incomplete";
+			const range = sourceRange(map, attrStart, close + 1);
+			props.push({
+				end: range.end,
+				name: attr,
+				start: range.start,
+				value: {
+					kind: "literal",
+					value: source.slice(cursor + 1, close)
+				},
+				written: source.slice(attrStart, close + 1)
+			});
+			cursor = close + 1;
+			continue;
+		}
+		if (opener === "{") {
+			const end = scanBalanced(source, cursor);
+			if (end === -1) return "braces";
+			const value = readBraced(source, cursor + 1, end - 1, map);
+			if (value !== null) {
+				const range = sourceRange(map, attrStart, end);
+				props.push({
+					end: range.end,
+					name: attr,
+					start: range.start,
+					value,
+					written: source.slice(attrStart, end)
+				});
+			}
+			cursor = end;
+			continue;
+		}
+		return "invalid";
+	}
+}
+function scanCloseTag(source, start, map) {
+	const name = matchAt(TAG_NAME, source, start + 2);
+	if (name === null) return start + 2 >= source.length ? "incomplete" : "invalid";
+	const cursor = skipSpace(source, start + 2 + name.length);
+	if (cursor >= source.length) return "incomplete";
+	if (source.charAt(cursor) !== ">") return "invalid";
+	const range = sourceRange(map, start, cursor + 1);
+	return {
+		end: cursor + 1,
+		token: {
+			end: range.end,
+			name,
+			start: range.start,
+			type: "close"
+		}
+	};
+}
+/**
+* Splits a run of Pickle into tags, `{expressions}` and text. While more input
+* may follow, an unclosed tag or `{` ends the run as `incomplete`. Once
+* `final`, nothing more can arrive: an unclosed `{` is kept as text and an
+* unclosed tag is dropped, each with a problem. `map` gives the source
+* offsets of `source`.
+*/
+function tokenizeInline(source, final, map) {
+	const tokens = [];
+	const problems = [];
+	let cursor = 0;
+	let text = "";
+	const flush = () => {
+		if (text !== "") {
+			tokens.push({
+				index: cursor - text.length,
+				type: "text",
+				value: text
+			});
+			text = "";
+		}
+	};
+	while (cursor < source.length) {
+		const char = source.charAt(cursor);
+		if (char === "<") {
+			const next = source.charAt(cursor + 1);
+			if (next === "" && !final) {
+				flush();
+				return {
+					inBraces: false,
+					incomplete: "tag",
+					problems,
+					tokens
+				};
+			}
+			if (next === "/" || /[A-Za-z]/.test(next)) {
+				const scan = next === "/" ? scanCloseTag(source, cursor, map) : scanOpenTag(source, cursor, map);
+				if (scan === "incomplete" || scan === "braces") {
+					flush();
+					if (!final) return {
+						inBraces: scan === "braces",
+						incomplete: "tag",
+						problems,
+						tokens
+					};
+					const slash = next === "/" ? "/" : "";
+					const name = matchAt(TAG_NAME, source, cursor + 1 + slash.length);
+					problems.push(`<${slash}${name ?? ""}> is unfinished: a closing quote, \`}\` or \`>\` is missing, so it and the rest of the line were removed`);
+					return {
+						inBraces: false,
+						incomplete: null,
+						problems,
+						tokens
+					};
+				}
+				if (scan !== "invalid") {
+					flush();
+					tokens.push(scan.token);
+					cursor = scan.end;
+					continue;
+				}
+			}
+		} else if (char === "{") {
+			const end = scanBalanced(source, cursor);
+			if (end === -1 && !final) {
+				flush();
+				return {
+					inBraces: false,
+					incomplete: "expression",
+					problems,
+					tokens
+				};
+			}
+			if (end === -1) {
+				problems.push("`{` has no matching `}`, so it was shown as text. Close the expression, or write {\"{\"} for a brace in text");
+				text += char;
+				cursor++;
+				continue;
+			}
+			flush();
+			const inner = source.slice(cursor + 1, end - 1);
+			const code = inner.trim();
+			if (!ONLY_COMMENTS.test(code)) {
+				const from = cursor + 1 + inner.length - inner.trimStart().length;
+				tokens.push({
+					at: sliceMap(map, from),
+					code,
+					type: "expr"
+				});
+			}
+			cursor = end;
+			continue;
+		}
+		text += char;
+		cursor++;
+	}
+	flush();
+	return {
+		inBraces: false,
+		incomplete: null,
+		problems,
+		tokens
+	};
+}
+function element(name, props, line, range, children = []) {
+	return {
+		children,
+		end: range.end,
+		line,
+		name,
+		props,
+		start: range.start,
+		type: "element"
+	};
+}
+function createTreeBuilder(repairs, errors) {
+	const root = element("#root", [], 0, {
+		end: 0,
+		start: 0
+	});
+	const stack = [];
+	const append = (node) => {
+		(stack.at(-1)?.node ?? root).children.push(node);
+	};
+	const open = (node, kind) => {
+		append(node);
+		const frame = {
+			kind,
+			node
+		};
+		stack.push(frame);
+		return frame;
+	};
+	const isOpen = (frame) => stack.includes(frame);
+	const insideTag = () => stack.some((frame) => frame.kind === "tag");
+	/** Closes `frame` and anything opened after it. */
+	const close = (frame) => {
+		const index = stack.indexOf(frame);
+		if (index === -1) return;
+		for (const above of stack.slice(index + 1)) if (above.kind === "tag") repairs.push({
+			end: above.node.end,
+			line: above.node.line,
+			message: `Closed unclosed <${above.node.name}>`,
+			start: above.node.start
+		});
+		stack.length = index;
+	};
+	const closeEmphasis = () => {
+		while (stack.at(-1)?.kind === "emphasis") stack.pop();
+	};
+	/** `index` is where `value` starts in the run `map` describes. */
+	const feedText = (value, line, map, index) => {
+		let buffer = "";
+		const flush = () => {
+			if (buffer !== "") {
+				append({
+					type: "text",
+					value: buffer
+				});
+				buffer = "";
+			}
+		};
+		let cursor = 0;
+		while (cursor < value.length) {
+			const char = value.charAt(cursor);
+			if (char === "`") {
+				const end = value.indexOf("`", cursor + 1);
+				if (end > cursor + 1) {
+					flush();
+					append(element("code", [], line, sourceRange(map, index + cursor, index + end + 1), [{
+						type: "text",
+						value: value.slice(cursor + 1, end)
+					}]));
+					cursor = end + 1;
+					continue;
+				}
+			}
+			if (char === "*") {
+				const name = value.startsWith("**", cursor) ? "bold" : "italic";
+				const width = name === "bold" ? 2 : 1;
+				const current = stack.findLast((frame) => frame.kind === "emphasis" && frame.node.name === name);
+				if (current && !isSpace(value.charAt(cursor - 1))) {
+					flush();
+					close(current);
+					cursor += width;
+					continue;
+				}
+				if (!current && !isSpace(value.charAt(cursor + width))) {
+					flush();
+					open(element(name, [], line, sourceRange(map, index + cursor, index + cursor + width)), "emphasis");
+					cursor += width;
+					continue;
+				}
+			}
+			buffer += char;
+			cursor++;
+		}
+		flush();
+	};
+	const feed = (tokens, line, dropBlankText, map) => {
+		const isExprAt = (index) => tokens[index]?.type === "expr";
+		for (const [index, token] of tokens.entries()) switch (token.type) {
+			case "open": {
+				const node = element(token.name, token.props, line, token);
+				if (token.selfClosing) {
+					node.closeEnd = token.end;
+					append(node);
+				} else open(node, "tag");
+				break;
+			}
+			case "close": {
+				const frame = stack.findLast((candidate) => candidate.kind === "tag" && candidate.node.name === token.name);
+				if (frame) {
+					frame.node.closeEnd = token.end;
+					close(frame);
+				} else repairs.push({
+					end: token.end,
+					line,
+					message: `Dropped stray </${token.name}>`,
+					start: token.start
+				});
+				break;
+			}
+			case "expr":
+				append({
+					at: token.at,
+					code: token.code,
+					line,
+					type: "expr"
+				});
+				break;
+			case "text": if (!dropBlankText || token.value.trim() !== "" || isExprAt(index - 1) && isExprAt(index + 1)) feedText(token.value, line, map, token.index);
+		}
+	};
+	/**
+	* A Markdown block (heading, paragraph, list item) whose content is inline
+	* Pickle. `map` gives the source offsets of `content`.
+	*/
+	const inlineBlock = (name, props, content, line, final, map) => {
+		const range = sourceRange(map, 0, content.length);
+		const frame = open(element(name, props, line, range), "block");
+		const inline = tokenizeInline(content, final, map);
+		for (const message of inline.problems) errors.push({
+			end: range.end,
+			line,
+			message,
+			start: range.start
+		});
+		if (inline.incomplete !== null) repairs.push({
+			line,
+			message: `Dropped incomplete ${inline.incomplete}`
+		});
+		feed(inline.tokens, line, false, map);
+		close(frame);
+	};
+	const finish = () => {
+		for (const frame of stack) if (frame.kind === "tag") repairs.push({
+			end: frame.node.end,
+			line: frame.node.line,
+			message: `Closed unclosed <${frame.node.name}>`,
+			start: frame.node.start
+		});
+		stack.length = 0;
+		return root.children;
+	};
+	return {
+		append,
+		close,
+		closeEmphasis,
+		feed,
+		finish,
+		inlineBlock,
+		insideTag,
+		isOpen,
+		open
+	};
+}
+const HEADING = /^(#{1,6})\s+(.*)$/;
+const LIST_ITEM = /^([-*+]|\d+[.)])\s+(.*)$/;
+const DIVIDER = /^(?:-{3,}|\*{3,})$/;
+const TAG_LINE = /^<\/?[A-Za-z]/;
+const STATEMENT_PREFIX = "{@body";
+const headingSizes = [
+	"xl",
+	"lg",
+	"md"
+];
+/**
+* Parses Pickle: Markdown blocks, catalog tags and `{@body ...}` statements.
+*
+* Never throws. Partial input (a response that is still being written) is
+* repaired: open elements are closed and a trailing incomplete tag, expression
+* or statement is dropped. Each fix is recorded in `repairs`.
+*
+* An unclosed tag, `{` or statement stops at the next tag line or `{@body`
+* line rather than swallowing the rest of the document; a tag also stops at a
+* blank line, unless one of its attributes has a `{` still open. Since that text can't be
+* finished by more streaming, it is reported in `errors`.
+*/
+function parsePickle(source) {
+	const lines = source.split(/\r?\n/);
+	const lineStarts = [0];
+	for (let newline = source.indexOf("\n"); newline !== -1; newline = source.indexOf("\n", newline + 1)) lineStarts.push(newline + 1);
+	/** Where line `at` (0-based) starts once trimmed. */
+	const trimmedStart = (at) => {
+		const raw = lines[at] ?? "";
+		return (lineStarts[at] ?? 0) + raw.length - raw.trimStart().length;
+	};
+	const repairs = [];
+	const errors = [];
+	const statements = [];
+	const builder = createTreeBuilder(repairs, errors);
+	let paragraph = null;
+	let list = null;
+	/** `final` unless the paragraph ends the input, where more may still stream in. */
+	const flushParagraph = (final = true) => {
+		if (paragraph !== null) {
+			builder.inlineBlock("text", [], paragraph.lines.join(" "), paragraph.line, final, paragraph.map);
+			paragraph = null;
+		}
+	};
+	const endList = () => {
+		if (list !== null) {
+			builder.close(list.frame);
+			list = null;
+		}
+	};
+	const endBlocks = (final = true) => {
+		flushParagraph(final);
+		endList();
+	};
+	/** Whether line `at` can continue an unclosed tag or statement: a new block can't. */
+	const continues = (at, blankLines) => {
+		const next = (lines[at] ?? "").trim();
+		return (blankLines || next !== "") && !next.startsWith(STATEMENT_PREFIX) && !TAG_LINE.test(next);
+	};
+	let index = 0;
+	while (index < lines.length) {
+		const line = index + 1;
+		const trimmed = (lines[index] ?? "").trim();
+		const lineMap = [[0, trimmedStart(index)]];
+		if (trimmed === "") {
+			endBlocks();
+			index++;
+			continue;
+		}
+		if (trimmed.startsWith(STATEMENT_PREFIX)) {
+			endBlocks();
+			let text = trimmed;
+			const map = [...lineMap];
+			let end = scanBalanced(text, 0);
+			while (end === -1 && index + 1 < lines.length && continues(index + 1, true)) {
+				index++;
+				extendMap(map, text.length + 1, lineStarts[index] ?? 0);
+				text += `\n${lines[index] ?? ""}`;
+				end = scanBalanced(text, 0);
+			}
+			index++;
+			if (end === -1 && index < lines.length) {
+				const range = sourceRange(map, 0, text.length);
+				errors.push({
+					end: range.end,
+					line,
+					message: "{@body} line has no closing `}` before the next tag or {@body} line, so it was removed. Close it on its own line",
+					start: range.start
+				});
+				continue;
+			}
+			if (end === -1) {
+				repairs.push({
+					line,
+					message: "Dropped incomplete {@body} statement"
+				});
+				continue;
+			}
+			const inner = text.slice(6, end - 1);
+			const code = inner.trim();
+			const at = sliceMap(map, 6 + inner.length - inner.trimStart().length);
+			const range = sourceRange(map, 0, end);
+			if (code !== "" && builder.insideTag()) builder.append({
+				at,
+				code,
+				line,
+				...range,
+				type: "statement"
+			});
+			else if (code !== "") statements.push({
+				at,
+				code,
+				line,
+				...range
+			});
+			continue;
+		}
+		if (TAG_LINE.test(trimmed)) {
+			endBlocks();
+			let text = trimmed;
+			const map = [...lineMap];
+			let result = tokenizeInline(text, false, map);
+			while (result.incomplete !== null && index + 1 < lines.length && continues(index + 1, result.inBraces)) {
+				index++;
+				extendMap(map, text.length + 1, trimmedStart(index));
+				text += `\n${(lines[index] ?? "").trim()}`;
+				result = tokenizeInline(text, false, map);
+			}
+			index++;
+			if (result.incomplete !== null && index < lines.length) result = tokenizeInline(text, true, map);
+			const range = sourceRange(map, 0, text.length);
+			for (const message of result.problems) errors.push({
+				end: range.end,
+				line,
+				message,
+				start: range.start
+			});
+			if (result.incomplete !== null) repairs.push({
+				line,
+				message: `Dropped incomplete ${result.incomplete}`
+			});
+			builder.feed(result.tokens, line, true, map);
+			builder.closeEmphasis();
+			continue;
+		}
+		index++;
+		/** The map of `content`, which ends the trimmed line. */
+		const contentMap = (content) => sliceMap(lineMap, trimmed.length - content.length);
+		const heading = HEADING.exec(trimmed);
+		if (heading) {
+			endBlocks();
+			const level = (heading[1] ?? "#").length;
+			const size = headingSizes[Math.min(level, headingSizes.length) - 1];
+			const content = heading[2] ?? "";
+			builder.inlineBlock("title", [{
+				name: "size",
+				value: {
+					kind: "literal",
+					value: size ?? "md"
+				}
+			}], content, line, true, contentMap(content));
+			continue;
+		}
+		if (DIVIDER.test(trimmed)) {
+			endBlocks();
+			builder.append(element("divider", [], line, sourceRange(lineMap, 0, trimmed.length)));
+			continue;
+		}
+		const item = LIST_ITEM.exec(trimmed);
+		if (item) {
+			flushParagraph();
+			const ordered = /\d/.test(item[1] ?? "");
+			if (list === null || list.ordered !== ordered || !builder.isOpen(list.frame)) {
+				endList();
+				const props = ordered ? [{
+					name: "ordered",
+					value: {
+						kind: "literal",
+						value: true
+					}
+				}] : [];
+				list = {
+					frame: builder.open(element("list", props, line, sourceRange(lineMap, 0, trimmed.length)), "block"),
+					ordered
+				};
+			}
+			const content = item[2] ?? "";
+			builder.inlineBlock("item", [], content, line, true, contentMap(content));
+			continue;
+		}
+		endList();
+		paragraph ??= {
+			line,
+			lines: [],
+			map: [],
+			width: 0
+		};
+		extendMap(paragraph.map, paragraph.width + (paragraph.lines.length > 0 ? 1 : 0), sourceOffset(lineMap, 0));
+		paragraph.width += trimmed.length + (paragraph.lines.length > 0 ? 1 : 0);
+		paragraph.lines.push(trimmed);
+	}
+	endBlocks(false);
+	return {
+		children: builder.finish(),
+		errors,
+		repairs,
+		statements
+	};
+}
+//#endregion
+export { parsePickle };