@effected/yaml 0.1.0

package/internal/diagnostics.js

@@ -0,0 +1,80 @@
+//#region src/internal/diagnostics.ts
+/** Error codes emitted by the lexer stage. */
+const YAML_LEX_ERROR_CODES = [
+	"UnexpectedCharacter",
+	"UnterminatedString",
+	"InvalidEscapeSequence",
+	"InvalidUnicode",
+	"UnterminatedBlockScalar",
+	"UnterminatedFlowCollection",
+	"InvalidDirective",
+	"InvalidTagHandle",
+	"InvalidAnchorName",
+	"UnexpectedByteOrderMark"
+];
+/** Error codes emitted by the CST-parser stage. */
+const YAML_PARSE_ERROR_CODES = [
+	"InvalidIndentation",
+	"DuplicateKey",
+	"UnexpectedToken",
+	"MissingValue",
+	"MissingKey",
+	"TabIndentation",
+	"InvalidBlockStructure",
+	"MalformedFlowCollection",
+	"NestingDepthExceeded"
+];
+/** Error codes emitted by the composer stage. */
+const YAML_COMPOSE_ERROR_CODES = [
+	"UndefinedAlias",
+	"DuplicateAnchor",
+	"CircularAlias",
+	"UnresolvedTag",
+	"InvalidTagValue",
+	"AliasCountExceeded",
+	"InvalidDirective"
+];
+/**
+* Error codes for the stringifier stage. The engine's only deliberate
+* stringify failure is the circular-reference guard (thrown as
+* `StringifyFailure`); the facade materializes it under this code so
+* `YamlStringifyError` carries structured diagnostics rather than a
+* `reason` string.
+*/
+const YAML_STRINGIFY_ERROR_CODES = ["CircularReference"];
+/**
+* Error codes for the modify stage (`YamlFormat.modify`'s path navigation
+* against an already-composed AST). Not raised by the parser/composer.
+*/
+const YAML_MODIFY_ERROR_CODES = [
+	"EmptyDocument",
+	"PathNotFound",
+	"InvalidIndex",
+	"NotNavigable"
+];
+/**
+* The single source of truth for which diagnostic codes are fatal to a
+* parse (vs. recoverable warnings-as-data). Replaces the v3 source's three
+* subtly-differing inline fatal lists with their union: fatality is a
+* property of the code, declared once.
+*/
+const FATAL_CODES = /* @__PURE__ */ new Set([
+	"UndefinedAlias",
+	"DuplicateAnchor",
+	"AliasCountExceeded",
+	"UnexpectedToken",
+	"InvalidDirective",
+	"MalformedFlowCollection",
+	"InvalidIndentation",
+	"TabIndentation",
+	"UnresolvedTag",
+	"UnexpectedCharacter",
+	"NestingDepthExceeded"
+]);
+/** Whether `code` is fatal to a parse. */
+function isFatalCode(code) {
+	return FATAL_CODES.has(code);
+}
+
+//#endregion
+export { FATAL_CODES, YAML_COMPOSE_ERROR_CODES, YAML_LEX_ERROR_CODES, YAML_MODIFY_ERROR_CODES, YAML_PARSE_ERROR_CODES, YAML_STRINGIFY_ERROR_CODES, isFatalCode };

package/internal/diff.js

@@ -0,0 +1,56 @@
+//#region src/internal/diff.ts
+/**
+* Compute edits by diffing two strings character by character.
+*
+* Walks both strings from each end inward to find the common prefix and
+* suffix, then emits a single edit covering the changed region in the
+* middle. This is sufficient because both strings derive from the same AST
+* and share structural skeleton — typically only whitespace and values differ.
+*
+* For more granular edits (multiple disjoint changes), a line-level pass
+* splits the middle region into per-line edits when possible.
+*
+* This relies on the assumption that both strings share an identical
+* structural skeleton (they were produced from the same AST); a simple
+* prefix/suffix match is sufficient and a full Myers diff is unnecessary.
+*/
+function computeEdits(original, modified) {
+	if (original === modified) return [];
+	let prefixLen = 0;
+	const minLen = Math.min(original.length, modified.length);
+	while (prefixLen < minLen && original[prefixLen] === modified[prefixLen]) prefixLen++;
+	let suffixLen = 0;
+	while (suffixLen < minLen - prefixLen && original[original.length - 1 - suffixLen] === modified[modified.length - 1 - suffixLen]) suffixLen++;
+	const origStart = prefixLen;
+	const origEnd = original.length - suffixLen;
+	const modStart = prefixLen;
+	const modEnd = modified.length - suffixLen;
+	if (origStart >= origEnd && modStart >= modEnd) return [];
+	const origMiddle = original.substring(origStart, origEnd);
+	const modMiddle = modified.substring(modStart, modEnd);
+	const origLines = origMiddle.split("\n");
+	const modLines = modMiddle.split("\n");
+	if (origLines.length === modLines.length && origLines.length > 1) {
+		const edits = [];
+		let offset = origStart;
+		for (let i = 0; i < origLines.length; i++) {
+			const origLine = origLines[i] ?? "";
+			const modLine = modLines[i] ?? "";
+			if (origLine !== modLine) edits.push({
+				offset,
+				length: origLine.length,
+				content: modLine
+			});
+			offset += origLine.length + 1;
+		}
+		return edits;
+	}
+	return [{
+		offset: origStart,
+		length: origEnd - origStart,
+		content: modified.substring(modStart, modEnd)
+	}];
+}
+
+//#endregion
+export { computeEdits };

package/internal/fold.js

@@ -0,0 +1,153 @@
+//#region src/internal/fold.ts
+/**
+* C0 control characters (except TAB) that must be escaped in double-quoted scalars.
+*/
+function isControlChar(code) {
+	return code >= 0 && code <= 8 || code === 11 || code === 12 || code >= 14 && code <= 31;
+}
+/**
+* Returns true when the value has whitespace immediately before a newline AND
+* the value contains a non-trailing newline. Equivalent to the regex pair
+* `/[\t ]\n/.test(s) && s.replace(/\n+$/, "").includes("\n")` but uses linear
+* imperative scans to avoid polynomial-time regex behaviour on adversarial
+* inputs containing many trailing newlines.
+*/
+function hasInteriorTrailingWhitespace(s) {
+	let firstWsBeforeNl = -1;
+	for (let i = 1; i < s.length; i++) if (s.charCodeAt(i) === 10) {
+		const prev = s.charCodeAt(i - 1);
+		if (prev === 32 || prev === 9) {
+			firstWsBeforeNl = i;
+			break;
+		}
+	}
+	if (firstWsBeforeNl < 0) return false;
+	let trailingStart = s.length;
+	while (trailingStart > 0 && s.charCodeAt(trailingStart - 1) === 10) trailingStart--;
+	for (let i = 0; i < trailingStart; i++) if (s.charCodeAt(i) === 10) return true;
+	return false;
+}
+/**
+* Returns true when the value contains a newline followed by one or more
+* spaces and then a tab — mixed leading whitespace on a continuation line
+* that block style cannot represent unambiguously.
+*/
+function hasNewlineSpacesTab(s) {
+	for (let i = 0; i < s.length - 2; i++) {
+		if (s.charCodeAt(i) !== 10) continue;
+		let j = i + 1;
+		while (j < s.length && s.charCodeAt(j) === 32) j++;
+		if (j > i + 1 && j < s.length && s.charCodeAt(j) === 9) return true;
+	}
+	return false;
+}
+/**
+* Renders a multi-line value as a single-quoted scalar with proper fold encoding.
+*
+* Single-quoted scalars use line folding rules (YAML 1.2 §7.4): bare newlines
+* between non-empty lines fold to a space; empty lines preserve as literal
+* newlines. To round-trip a value with N consecutive literal newlines, the
+* source needs N+1 consecutive source newlines (i.e., one extra to account
+* for the bare newline that would otherwise fold to a space).
+*
+* Continuation lines are prefixed with the given indent. Leading whitespace
+* on continuation lines after the indent is preserved as part of the content
+* because empty lines precede them, suppressing the fold-to-space rule.
+*
+* Returns null if the content cannot safely be represented as single-quoted
+* (carriage returns or non-tab control characters).
+*/
+function renderSingleQuotedMultiline(s, indent) {
+	for (let i = 0; i < s.length; i++) {
+		const code = s.charCodeAt(i);
+		if (code === 13 || isControlChar(code)) return null;
+	}
+	const escaped = s.replace(/'/g, "''");
+	let result = "";
+	let i = 0;
+	let firstSegment = true;
+	while (i < escaped.length) {
+		let segEnd = i;
+		while (segEnd < escaped.length && escaped[segEnd] !== "\n") segEnd++;
+		const segment = escaped.slice(i, segEnd);
+		if (firstSegment) {
+			result += segment;
+			firstSegment = false;
+		} else result += `${indent}${segment}`;
+		i = segEnd;
+		let nlEnd = i;
+		while (nlEnd < escaped.length && escaped[nlEnd] === "\n") nlEnd++;
+		const nlCount = nlEnd - i;
+		if (nlCount > 0) result += "\n".repeat(nlCount + 1);
+		i = nlEnd;
+	}
+	return `'${result}'`;
+}
+/**
+* Renders a string scalar using block literal style (pipe `|`).
+*
+* @param explicitChomp - Original chomp indicator from the AST, when known.
+* `keep` (`+`) and `strip` (`-`) preserve trailing-newline semantics that
+* cannot be inferred from the resolved value alone.
+*/
+function renderBlockLiteral(s, indent, explicitChomp, parentPosition) {
+	let chomp = "";
+	const onlyNewlines = s.length > 0 && /^\n+$/.test(s);
+	if (s.endsWith("\n\n") || onlyNewlines && explicitChomp === "keep") chomp = "+";
+	else if (!s.endsWith("\n")) chomp = "-";
+	const lines = s.split("\n");
+	if (s.endsWith("\n")) lines.pop();
+	let indentIndicator = "";
+	const firstContent = lines.find((l) => l !== "");
+	const hasContent = firstContent !== void 0;
+	if (firstContent?.startsWith(" ") || lines.length > 0 && lines[0] === "" && hasContent) indentIndicator = String(indent.length);
+	else if (!hasContent && chomp === "+" && parentPosition === "block-map-value" && indent.length > 0) indentIndicator = String(indent.length);
+	return `|${indentIndicator}${chomp}\n${lines.map((l) => l === "" ? "" : `${indent}${l}`).join("\n")}`;
+}
+/**
+* Renders a string scalar using block folded style (greater-than `>`).
+*
+* In folded block scalars, a single newline between content lines is folded
+* into a space by the reader. To preserve a literal newline in the value,
+* the output must contain an empty line (double newline). Each empty line
+* in the value already produces the correct number of blank lines.
+*/
+function renderBlockFolded(s, indent) {
+	let chomp = "";
+	if (s.endsWith("\n\n")) chomp = "+";
+	else if (!s.endsWith("\n")) chomp = "-";
+	const valueLines = s.split("\n");
+	if (s.endsWith("\n")) valueLines.pop();
+	let indentIndicator = "";
+	const firstContent = valueLines.find((l) => l !== "");
+	if (firstContent?.startsWith(" ") || valueLines.length >= 2 && valueLines[0] === "" && valueLines[1] === "" && firstContent !== void 0) indentIndicator = String(indent.length);
+	const outputLines = [];
+	let prevNonEmpty = false;
+	let prevMoreIndented = false;
+	for (let i = 0; i < valueLines.length; i++) {
+		const line = valueLines[i];
+		if (line === "") {
+			if (prevNonEmpty && !prevMoreIndented) {
+				let nextContentMoreIndented = false;
+				for (let j = i + 1; j < valueLines.length; j++) if (valueLines[j] !== "") {
+					nextContentMoreIndented = valueLines[j].startsWith(" ") || valueLines[j].startsWith("	");
+					break;
+				}
+				if (!nextContentMoreIndented) outputLines.push("");
+			}
+			outputLines.push("");
+			prevNonEmpty = false;
+			prevMoreIndented = false;
+		} else {
+			const isMoreIndented = line.startsWith(" ") || line.startsWith("	");
+			if (prevNonEmpty && !isMoreIndented) outputLines.push("");
+			outputLines.push(`${indent}${line}`);
+			prevNonEmpty = true;
+			prevMoreIndented = isMoreIndented;
+		}
+	}
+	return `>${indentIndicator}${chomp}\n${outputLines.join("\n")}`;
+}
+
+//#endregion
+export { hasInteriorTrailingWhitespace, hasNewlineSpacesTab, isControlChar, renderBlockFolded, renderBlockLiteral, renderSingleQuotedMultiline };