@effected/yaml 0.1.0

package/internal/composer/flow.js

@@ -0,0 +1,400 @@
+import { YamlMap, YamlScalar, YamlSeq } from "../../YamlNode.js";
+import { checkAnchorOnAlias, getAnchorName, makeAlias, registerAnchor } from "./anchors.js";
+import { enterNesting, exitNesting, hasMeta } from "./state.js";
+import { collectMultilineKey, collectMultilinePlainScalar, getScalarStyle, hasValueSepThroughPlainScalars, makeScalar, resolveScalar } from "./scalars.js";
+import { buildPairs, checkDuplicateKeys, checkMultilineImplicitKeys } from "./block.js";
+
+//#region src/internal/composer/flow.ts
+/**
+* Validate that flow collection entries are separated by commas.
+*
+* Detects the specific pattern: content, `:`, content, content (no comma).
+* This catches `{foo: 1 bar: 2}` while allowing multiline plain scalars
+* like `{multi\n  line: value}` (consecutive scalars without colon between).
+*
+* State machine: idle → saw-colon → saw-value → error-if-no-comma
+*/
+function validateFlowSeparators(children, state, openBracket, closeBracket) {
+	let colonCount = 0;
+	let contentAfterColon = 0;
+	for (const child of children) {
+		if (child.type === "whitespace" && (child.source === openBracket || child.source === closeBracket)) continue;
+		if (child.type === "newline") continue;
+		if (child.type === "comment") {
+			if (contentAfterColon > 0) {
+				colonCount = 1;
+				contentAfterColon = 1;
+			}
+			continue;
+		}
+		if (child.type === "whitespace" && child.source.trim() === "") continue;
+		if (child.type === "whitespace" && child.source === ",") {
+			colonCount = 0;
+			contentAfterColon = 0;
+			continue;
+		}
+		if (child.type === "whitespace" && child.source === ":") {
+			colonCount++;
+			contentAfterColon = 0;
+			continue;
+		}
+		if (child.type === "flow-scalar" || child.type === "block-scalar" || child.type === "flow-map" || child.type === "flow-seq" || child.type === "alias") {
+			contentAfterColon++;
+			if (colonCount > 0 && contentAfterColon > 1) state.errors.push({
+				code: "MalformedFlowCollection",
+				message: "Missing comma between flow collection entries",
+				offset: child.offset,
+				length: child.length
+			});
+		}
+	}
+}
+/**
+* 9C9N, VJP3/00: continuation lines of multi-line flow content must be
+* indented past the parent block context. Caller passes the parent block
+* column; for document-root flow content (no parent block) the caller
+* omits it and the check is skipped.
+*/
+function validateFlowContentIndent(cst, state, parentBlockColumn) {
+	if (parentBlockColumn === void 0 || parentBlockColumn < 0) return;
+	const text = state.text;
+	const start = cst.offset;
+	const end = cst.offset + cst.length;
+	let i = start;
+	let inLineStart = false;
+	let lineStart = -1;
+	while (i < end && i < text.length) {
+		const ch = text[i];
+		if (ch === "\n") {
+			inLineStart = true;
+			lineStart = i + 1;
+			i++;
+			continue;
+		}
+		if (inLineStart) {
+			if (ch === " " || ch === "	") {
+				i++;
+				continue;
+			}
+			if (i - lineStart <= parentBlockColumn) {
+				state.errors.push({
+					code: "InvalidIndentation",
+					message: "Flow content continuation line must be indented past the parent block",
+					offset: i,
+					length: 1
+				});
+				return;
+			}
+			inLineStart = false;
+		}
+		i++;
+	}
+}
+function composeFlowMap(cst, state, meta, parentBlockColumn) {
+	if (!enterNesting(state, cst)) return new YamlMap({
+		items: [],
+		style: "flow",
+		offset: cst.offset,
+		length: cst.length
+	});
+	try {
+		return composeFlowMapInner(cst, state, meta, parentBlockColumn);
+	} finally {
+		exitNesting(state);
+	}
+}
+function composeFlowMapInner(cst, state, meta, parentBlockColumn) {
+	const children = cst.children ?? [];
+	const pairs = [];
+	const hasOpen = children.some((c) => c.type === "whitespace" && c.source === "{");
+	const hasClose = children.some((c) => c.type === "whitespace" && c.source === "}");
+	if (hasOpen && !hasClose) state.errors.push({
+		code: "MalformedFlowCollection",
+		message: "Unclosed flow mapping (missing `}`)",
+		offset: cst.offset,
+		length: cst.length
+	});
+	validateFlowContentIndent(cst, state, parentBlockColumn);
+	validateFlowSeparators(children, state, "{", "}");
+	buildPairs(flattenFlowChildren(children.filter((c) => !(c.type === "whitespace" && (c.source === "{" || c.source === "}" || c.source.trim() === ""))), state), pairs, state.text);
+	if (state.options.uniqueKeys) checkDuplicateKeys(pairs, state);
+	const map = new YamlMap({
+		items: pairs,
+		style: "flow",
+		offset: cst.offset,
+		length: cst.length,
+		...meta?.tag !== void 0 ? { tag: meta.tag } : {},
+		...meta?.anchor !== void 0 ? { anchor: meta.anchor } : {},
+		...meta?.comment !== void 0 ? { comment: meta.comment } : {}
+	});
+	if (meta?.anchor) registerAnchor(map, meta.anchor, state, cst.offset);
+	return map;
+}
+function flattenFlowChildren(children, state) {
+	const items = [];
+	let pendingMeta = {};
+	for (let i = 0; i < children.length; i++) {
+		const child = children[i];
+		if (!child) continue;
+		if (child.type === "newline") continue;
+		if (child.type === "whitespace") {
+			if (child.source === ",") {
+				if (hasMeta(pendingMeta)) {
+					const scalar = new YamlScalar({
+						value: resolveScalar("", "plain", pendingMeta.tag, state),
+						style: "plain",
+						offset: child.offset,
+						length: 0,
+						...pendingMeta.tag !== void 0 ? { tag: pendingMeta.tag } : {},
+						...pendingMeta.anchor !== void 0 ? { anchor: pendingMeta.anchor } : {}
+					});
+					if (pendingMeta.anchor) registerAnchor(scalar, pendingMeta.anchor, state, child.offset);
+					pendingMeta = {};
+					items.push({
+						kind: "node",
+						node: scalar
+					});
+				}
+				continue;
+			}
+			if (child.source === ":") {
+				if (hasMeta(pendingMeta)) {
+					const scalar = new YamlScalar({
+						value: resolveScalar("", "plain", pendingMeta.tag, state),
+						style: "plain",
+						offset: child.offset,
+						length: 0,
+						...pendingMeta.tag !== void 0 ? { tag: pendingMeta.tag } : {},
+						...pendingMeta.anchor !== void 0 ? { anchor: pendingMeta.anchor } : {}
+					});
+					if (pendingMeta.anchor) registerAnchor(scalar, pendingMeta.anchor, state, child.offset);
+					pendingMeta = {};
+					items.push({
+						kind: "node",
+						node: scalar
+					});
+				}
+				items.push({
+					kind: "value-sep",
+					offset: child.offset
+				});
+			}
+			if (child.source === "?") items.push({ kind: "key" });
+			continue;
+		}
+		if (child.type === "comment") {
+			items.push({
+				kind: "comment",
+				comment: child.source.startsWith("#") ? child.source.slice(1).trim() : child.source
+			});
+			continue;
+		}
+		if (child.type === "error") {
+			state.errors.push({
+				code: "UnexpectedToken",
+				message: `Unexpected content: ${child.source.trim() || "(empty)"}`,
+				offset: child.offset,
+				length: child.length
+			});
+			continue;
+		}
+		if (child.type === "anchor") {
+			pendingMeta.anchor = getAnchorName(child, state.text);
+			continue;
+		}
+		if (child.type === "tag") {
+			pendingMeta.tag = child.source;
+			continue;
+		}
+		if (child.type === "flow-scalar" || child.type === "block-scalar") {
+			if (child.type === "flow-scalar" && getScalarStyle(child) === "plain" && child.source.startsWith("#") && child.offset > 0) {
+				const prev = state.text[child.offset - 1];
+				if (prev !== " " && prev !== "	" && prev !== "\n" && prev !== "\r") state.errors.push({
+					code: "UnexpectedToken",
+					message: "Comment must be preceded by whitespace",
+					offset: child.offset,
+					length: child.length
+				});
+			}
+			if (child.type === "flow-scalar" && getScalarStyle(child) === "plain" && (child.source === "-" || child.source === "?")) state.errors.push({
+				code: "UnexpectedToken",
+				message: `Invalid plain scalar '${child.source}' in flow context`,
+				offset: child.offset,
+				length: child.length
+			});
+			if (child.type === "flow-scalar" && getScalarStyle(child) === "plain") {
+				if (hasValueSepThroughPlainScalars(children, i + 1)) {
+					const { value, nextIdx } = collectMultilineKey(children, i);
+					const scalar = new YamlScalar({
+						value: resolveScalar(value, "plain", pendingMeta.tag, state),
+						style: "plain",
+						offset: child.offset,
+						length: child.length,
+						...pendingMeta.tag !== void 0 ? { tag: pendingMeta.tag } : {},
+						...pendingMeta.anchor !== void 0 ? { anchor: pendingMeta.anchor } : {}
+					});
+					if (pendingMeta.anchor) registerAnchor(scalar, pendingMeta.anchor, state, child.offset);
+					pendingMeta = {};
+					items.push({
+						kind: "node",
+						node: scalar
+					});
+					i = nextIdx - 1;
+					continue;
+				}
+				const { value, nextIdx, partsCount, endOffset } = collectMultilinePlainScalar(children, i, void 0, state.text);
+				const scalar = new YamlScalar({
+					value: resolveScalar(value, "plain", pendingMeta.tag, state),
+					style: "plain",
+					offset: child.offset,
+					length: partsCount > 1 ? endOffset - child.offset : child.length,
+					...pendingMeta.tag !== void 0 ? { tag: pendingMeta.tag } : {},
+					...pendingMeta.anchor !== void 0 ? { anchor: pendingMeta.anchor } : {}
+				});
+				if (pendingMeta.anchor) registerAnchor(scalar, pendingMeta.anchor, state, child.offset);
+				pendingMeta = {};
+				items.push({
+					kind: "node",
+					node: scalar
+				});
+				i = nextIdx - 1;
+				continue;
+			}
+			const scalar = makeScalar(child, state, hasMeta(pendingMeta) ? pendingMeta : void 0);
+			pendingMeta = {};
+			items.push({
+				kind: "node",
+				node: scalar
+			});
+			continue;
+		}
+		if (child.type === "alias") {
+			checkAnchorOnAlias(pendingMeta, child, state);
+			const alias = makeAlias(child, state);
+			pendingMeta = {};
+			items.push({
+				kind: "node",
+				node: alias
+			});
+			continue;
+		}
+		if (child.type === "flow-map") {
+			const map = composeFlowMap(child, state, hasMeta(pendingMeta) ? pendingMeta : void 0);
+			pendingMeta = {};
+			items.push({
+				kind: "node",
+				node: map
+			});
+			continue;
+		}
+		if (child.type === "flow-seq") {
+			const seq = composeFlowSeq(child, state, hasMeta(pendingMeta) ? pendingMeta : void 0);
+			pendingMeta = {};
+			items.push({
+				kind: "node",
+				node: seq
+			});
+		}
+	}
+	if (hasMeta(pendingMeta)) {
+		const scalar = new YamlScalar({
+			value: resolveScalar("", "plain", pendingMeta.tag, state),
+			style: "plain",
+			offset: 0,
+			length: 0,
+			...pendingMeta.tag !== void 0 ? { tag: pendingMeta.tag } : {},
+			...pendingMeta.anchor !== void 0 ? { anchor: pendingMeta.anchor } : {}
+		});
+		if (pendingMeta.anchor) registerAnchor(scalar, pendingMeta.anchor, state, 0);
+		items.push({
+			kind: "node",
+			node: scalar
+		});
+	}
+	return items;
+}
+function composeFlowSeq(cst, state, meta, parentBlockColumn) {
+	if (!enterNesting(state, cst)) return new YamlSeq({
+		items: [],
+		style: "flow",
+		offset: cst.offset,
+		length: cst.length
+	});
+	try {
+		return composeFlowSeqInner(cst, state, meta, parentBlockColumn);
+	} finally {
+		exitNesting(state);
+	}
+}
+function composeFlowSeqInner(cst, state, meta, parentBlockColumn) {
+	const children = cst.children ?? [];
+	const items = [];
+	validateFlowContentIndent(cst, state, parentBlockColumn);
+	validateFlowSeparators(children, state, "[", "]");
+	const hasOpen = children.some((c) => c.type === "whitespace" && c.source === "[");
+	const hasClose = children.some((c) => c.type === "whitespace" && c.source === "]");
+	if (hasOpen && !hasClose) state.errors.push({
+		code: "MalformedFlowCollection",
+		message: "Unclosed flow sequence (missing `]`)",
+		offset: cst.offset,
+		length: cst.length
+	});
+	const segments = [];
+	let current = [];
+	let seenContent = false;
+	let lastWasComma = false;
+	for (const child of children) {
+		if (child.type === "whitespace" && (child.source === "[" || child.source === "]")) continue;
+		if (child.type === "whitespace" && child.source === ",") {
+			if (!current.some((c) => c.type !== "whitespace" && c.type !== "newline" && c.type !== "comment") && (lastWasComma || !seenContent)) state.errors.push({
+				code: "MalformedFlowCollection",
+				message: "Empty entry in flow sequence",
+				offset: child.offset,
+				length: 1
+			});
+			if (current.length > 0) segments.push(current);
+			current = [];
+			lastWasComma = true;
+			continue;
+		}
+		if (child.type !== "whitespace" && child.type !== "newline" && child.type !== "comment") {
+			seenContent = true;
+			lastWasComma = false;
+		}
+		current.push(child);
+	}
+	if (current.length > 0) segments.push(current);
+	for (const segment of segments) if (segment.some((c) => c.type === "whitespace" && c.source === ":")) {
+		const semItems = flattenFlowChildren(segment.filter((c) => !(c.type === "whitespace" && c.source.trim() === "")), state);
+		const pairs = [];
+		buildPairs(semItems, pairs, state.text);
+		if (!segment.some((c) => c.type === "whitespace" && c.source === "?")) checkMultilineImplicitKeys(pairs, state, semItems);
+		const firstPair = pairs[0];
+		if (firstPair) {
+			const map = new YamlMap({
+				items: pairs,
+				style: "flow",
+				offset: firstPair.key.offset,
+				length: 0
+			});
+			items.push(map);
+		}
+	} else {
+		const semItems = flattenFlowChildren(segment.filter((c) => !(c.type === "whitespace" && c.source.trim() === "")), state);
+		for (const si of semItems) if (si.kind === "node" && si.node) items.push(si.node);
+	}
+	const seq = new YamlSeq({
+		items,
+		style: "flow",
+		offset: cst.offset,
+		length: cst.length,
+		...meta?.tag !== void 0 ? { tag: meta.tag } : {},
+		...meta?.anchor !== void 0 ? { anchor: meta.anchor } : {},
+		...meta?.comment !== void 0 ? { comment: meta.comment } : {}
+	});
+	if (meta?.anchor) registerAnchor(seq, meta.anchor, state, cst.offset);
+	return seq;
+}
+
+//#endregion
+export { composeFlowMap, composeFlowSeq, flattenFlowChildren };