@samva/markup 0.4.0 → 0.6.0

package/dist/ops-2aiiYO7m.js

@@ -0,0 +1,630 @@
+import { documentChannel } from "./ast.js";
+import { CHANNEL_TAG_SPECS, allowedChildren, parseSml } from "./parser.js";
+import { compileSml } from "./compile.js";
+import { a as isBreakingCompatibilityCheck, r as checkSmlCompatibility } from "./checks-DBweSIPN.js";
+import { printSml } from "./printer.js";
+import { Result, TaggedError } from "better-result";
+//#region src/internal/sha256.ts
+const ROUND_CONSTANTS = new Uint32Array([
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+]);
+const rotateRight = (value, count) => value >>> count | value << 32 - count;
+/**
+* Encode valid Unicode as UTF-8 while preserving lone UTF-16 surrogates as
+* their three-byte WTF-8 form. TextEncoder replaces every lone surrogate with
+* U+FFFD, which would make distinct JavaScript source strings hash identically.
+*/
+const encodeSource = (source) => {
+	const output = [];
+	for (let index = 0; index < source.length; index++) {
+		const first = source.charCodeAt(index);
+		let codePoint = first;
+		if (first >= 55296 && first <= 56319) {
+			const second = source.charCodeAt(index + 1);
+			if (second >= 56320 && second <= 57343) {
+				codePoint = 65536 + (first - 55296 << 10) + (second - 56320);
+				index++;
+			}
+		}
+		if (codePoint <= 127) output.push(codePoint);
+		else if (codePoint <= 2047) output.push(192 | codePoint >>> 6, 128 | codePoint & 63);
+		else if (codePoint <= 65535) output.push(224 | codePoint >>> 12, 128 | codePoint >>> 6 & 63, 128 | codePoint & 63);
+		else output.push(240 | codePoint >>> 18, 128 | codePoint >>> 12 & 63, 128 | codePoint >>> 6 & 63, 128 | codePoint & 63);
+	}
+	return Uint8Array.from(output);
+};
+/** Browser-safe synchronous SHA-256 for compiler identity tokens. */
+const sha256 = (source) => {
+	const bytes = encodeSource(source);
+	const paddedLength = Math.ceil((bytes.length + 9) / 64) * 64;
+	const padded = new Uint8Array(paddedLength);
+	padded.set(bytes);
+	padded[bytes.length] = 128;
+	const view = new DataView(padded.buffer);
+	const bitLength = bytes.length * 8;
+	view.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296));
+	view.setUint32(paddedLength - 4, bitLength >>> 0);
+	const state = new Uint32Array([
+		1779033703,
+		3144134277,
+		1013904242,
+		2773480762,
+		1359893119,
+		2600822924,
+		528734635,
+		1541459225
+	]);
+	const words = /* @__PURE__ */ new Uint32Array(64);
+	for (let offset = 0; offset < paddedLength; offset += 64) {
+		for (let index = 0; index < 16; index++) words[index] = view.getUint32(offset + index * 4);
+		for (let index = 16; index < 64; index++) {
+			const previous15 = words[index - 15];
+			const previous2 = words[index - 2];
+			const sigma0 = rotateRight(previous15, 7) ^ rotateRight(previous15, 18) ^ previous15 >>> 3;
+			const sigma1 = rotateRight(previous2, 17) ^ rotateRight(previous2, 19) ^ previous2 >>> 10;
+			words[index] = words[index - 16] + sigma0 + words[index - 7] + sigma1 >>> 0;
+		}
+		let a = state[0];
+		let b = state[1];
+		let c = state[2];
+		let d = state[3];
+		let e = state[4];
+		let f = state[5];
+		let g = state[6];
+		let h = state[7];
+		for (let index = 0; index < 64; index++) {
+			const sum1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+			const choice = e & f ^ ~e & g;
+			const temporary1 = h + sum1 + choice + ROUND_CONSTANTS[index] + words[index] >>> 0;
+			const temporary2 = (rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22)) + (a & b ^ a & c ^ b & c) >>> 0;
+			h = g;
+			g = f;
+			f = e;
+			e = d + temporary1 >>> 0;
+			d = c;
+			c = b;
+			b = a;
+			a = temporary1 + temporary2 >>> 0;
+		}
+		state[0] = state[0] + a >>> 0;
+		state[1] = state[1] + b >>> 0;
+		state[2] = state[2] + c >>> 0;
+		state[3] = state[3] + d >>> 0;
+		state[4] = state[4] + e >>> 0;
+		state[5] = state[5] + f >>> 0;
+		state[6] = state[6] + g >>> 0;
+		state[7] = state[7] + h >>> 0;
+	}
+	return [...state].map((word) => word.toString(16).padStart(8, "0")).join("");
+};
+//#endregion
+//#region src/ops.ts
+var SmlOpError = class extends TaggedError("SmlOpError") {
+	constructor(args) {
+		super({
+			diagnostics: args.diagnostics,
+			message: args.diagnostics.map((diagnostic) => diagnostic.message).join("\n")
+		});
+	}
+};
+const zeroSpan = {
+	start: 0,
+	end: 0
+};
+const diagnostic = (code, message, span = zeroSpan) => ({
+	code,
+	message,
+	span
+});
+const cloneAttribute = (attribute) => ({ ...attribute });
+/**
+* Deep-copy a subtree, blanking every id to "". A duplicated node must not
+* alias the original's object graph or share its ids: batch ids resolve
+* against the pre-batch snapshot, and mapElement transforms every node whose
+* id matches — so two live copies sharing an id would both be rewritten by a
+* later op. Blank ids make the clone unaddressable (like any freshly created
+* node) until the next reprint reassigns positional ids.
+*/
+const cloneSubtree = (node) => {
+	if (node.kind === "element") return {
+		...node,
+		id: "",
+		attributes: node.attributes.map(cloneAttribute),
+		children: node.children.map(cloneSubtree)
+	};
+	return {
+		...node,
+		id: ""
+	};
+};
+const makeAttribute = (name, value) => ({
+	name,
+	value,
+	span: zeroSpan,
+	valueSpan: zeroSpan
+});
+const classAttr = (value) => makeAttribute("class", {
+	kind: "string",
+	value
+});
+const sourceRevision = (source) => `sml:${sha256(source)}`;
+const normalizeSml = (source) => {
+	const parsed = parseSml(source);
+	if (Result.isError(parsed)) return Result.err(parsed.error);
+	return Result.ok(printSml(parsed.value));
+};
+const findElement = (node, nodeId) => {
+	if (node.kind !== "element") return null;
+	if (node.id === nodeId) return node;
+	for (const child of node.children) {
+		const found = findElement(child, nodeId);
+		if (found !== null) return found;
+	}
+	return null;
+};
+const mapElement = (node, targetId, transform) => {
+	if (node.kind !== "element") return node;
+	if (node.id === targetId) return transform(node);
+	return {
+		...node,
+		children: node.children.map((child) => mapElement(child, targetId, transform))
+	};
+};
+const transformElement = (document, targetId, transform) => {
+	if (findElement(document.root, targetId) === null) return Result.err([diagnostic("op-target-not-found", `node "${targetId}" was not found in the current source`)]);
+	return Result.ok({
+		...document,
+		root: mapElement(document.root, targetId, transform)
+	});
+};
+const setElementAttribute = (element, name, value) => {
+	const rest = element.attributes.filter((attribute) => attribute.name !== name);
+	if (value === null || value.kind === "string" && value.value === "") return {
+		...element,
+		attributes: rest
+	};
+	const next = makeAttribute(name, value);
+	const attributes = element.attributes.some((attribute) => attribute.name === name) ? element.attributes.map((attribute) => attribute.name === name ? next : cloneAttribute(attribute)) : [...element.attributes, next];
+	return {
+		...element,
+		attributes
+	};
+};
+const setImageSchemeSource = (document, nodeId, scheme, value) => transformElement(document, nodeId, (element) => {
+	if (element.tag !== "Image") return element;
+	const src = value?.kind === "string" ? value.value : "";
+	const children = element.children.filter((child) => !(child.kind === "element" && child.tag === "Source" && child.attributes.some((attribute) => attribute.name === "scheme" && attribute.value.kind === "string" && attribute.value.value === scheme)));
+	if (src === "") return {
+		...element,
+		children
+	};
+	const sourceNode = {
+		kind: "element",
+		id: "",
+		tag: "Source",
+		attributes: [makeAttribute("scheme", {
+			kind: "string",
+			value: scheme
+		}), makeAttribute("src", {
+			kind: "string",
+			value: src
+		})],
+		children: [],
+		span: zeroSpan
+	};
+	return {
+		...element,
+		children: [...children, sourceNode]
+	};
+});
+const setProp = (document, op) => {
+	if (op.name === "src:dark") return setImageSchemeSource(document, op.nodeId, "dark", op.value);
+	return transformElement(document, op.nodeId, (element) => {
+		const value = op.name === "class" && op.value?.kind === "string" ? {
+			kind: "string",
+			value: op.value.value.trim().replace(/\s+/g, " ")
+		} : op.value;
+		return setElementAttribute(element, op.name, value);
+	});
+};
+const setChildren = (document, op) => transformElement(document, op.nodeId, (element) => ({
+	...element,
+	children: [...op.children]
+}));
+const makeColumn = () => ({
+	kind: "element",
+	id: "",
+	tag: "Column",
+	attributes: [classAttr("px-8")],
+	children: [{
+		kind: "element",
+		id: "",
+		tag: "Text",
+		attributes: [classAttr("text-base text-gray-700")],
+		children: [{
+			kind: "text",
+			id: "",
+			value: "Column",
+			span: zeroSpan
+		}],
+		span: zeroSpan
+	}],
+	span: zeroSpan
+});
+const makeBlock = (tag) => {
+	const base = (attributes, children) => ({
+		kind: "element",
+		id: "",
+		tag,
+		attributes,
+		children,
+		span: zeroSpan
+	});
+	const text = (value) => ({
+		kind: "text",
+		id: "",
+		value,
+		span: zeroSpan
+	});
+	switch (tag) {
+		case "Heading": return base([makeAttribute("level", {
+			kind: "number",
+			value: 2
+		}), classAttr("text-xl text-gray-900")], [text("Heading")]);
+		case "Text": return base([classAttr("text-base text-gray-700")], [text("Add your text here.")]);
+		case "Button": return base([makeAttribute("href", {
+			kind: "string",
+			value: "https://example.com"
+		}), classAttr("bg-blue-600 text-white px-20 py-12 rounded-md")], [text("Button")]);
+		case "Image": return base([
+			makeAttribute("src", {
+				kind: "string",
+				value: "https://placehold.co/600x200"
+			}),
+			makeAttribute("alt", {
+				kind: "string",
+				value: ""
+			}),
+			makeAttribute("width", {
+				kind: "number",
+				value: 600
+			})
+		], []);
+		case "Divider": return base([classAttr("border-gray-200")], []);
+		case "Spacer": return base([makeAttribute("height", {
+			kind: "number",
+			value: 24
+		})], []);
+		case "Section": return base([classAttr("py-16")], [makeBlock("Text")]);
+		case "Container": return base([classAttr("bg-white p-24")], [makeBlock("Text")]);
+		case "Row": return base([], [makeColumn(), makeColumn()]);
+		default: return base([], []);
+	}
+};
+const elementChildIndexToNodeIndex = (children, insertionIndex) => {
+	if (insertionIndex <= 0) {
+		const firstElement = children.findIndex((child) => child.kind === "element");
+		return firstElement === -1 ? children.length : firstElement;
+	}
+	let elementIndex = 0;
+	for (let index = 0; index < children.length; index++) {
+		if (children[index]?.kind !== "element") continue;
+		if (elementIndex === insertionIndex) return index;
+		elementIndex++;
+	}
+	return children.length;
+};
+const insertChildren = (document, childrenToInsert, referenceId, position) => {
+	if (childrenToInsert.length === 0) return Result.err([diagnostic("op-empty-insert", "insert operation produced no element nodes")]);
+	if (referenceId === null || referenceId === document.root.id) {
+		const children = position === "before" ? [...childrenToInsert, ...document.root.children] : [...document.root.children, ...childrenToInsert];
+		return Result.ok({
+			...document,
+			root: {
+				...document.root,
+				children
+			}
+		});
+	}
+	if (findElement(document.root, referenceId) === null) return Result.err([diagnostic("op-target-not-found", `node "${referenceId}" was not found in the current source`)]);
+	if (position === "inside") return transformElement(document, referenceId, (element) => ({
+		...element,
+		children: [...element.children, ...childrenToInsert]
+	}));
+	const insertInParent = (node) => {
+		if (node.kind !== "element") return node;
+		const index = node.children.findIndex((child) => child.kind === "element" && child.id === referenceId);
+		if (index >= 0) {
+			const at = position === "after" ? index + 1 : index;
+			return {
+				...node,
+				children: [
+					...node.children.slice(0, at),
+					...childrenToInsert,
+					...node.children.slice(at)
+				]
+			};
+		}
+		return {
+			...node,
+			children: node.children.map(insertInParent)
+		};
+	};
+	return Result.ok({
+		...document,
+		root: insertInParent(document.root)
+	});
+};
+const insertBlock = (document, op) => insertChildren(document, [makeBlock(op.tag)], op.referenceId, op.position);
+const insertSnippet = (document, op) => {
+	const rootTag = document.root.tag;
+	const parsed = parseSml(`<${rootTag}>${op.snippet}</${rootTag}>`);
+	if (Result.isError(parsed)) return Result.err(parsed.error.diagnostics);
+	const children = parsed.value.root.children.filter((child) => child.kind === "element");
+	return insertChildren(document, children, op.referenceId, op.position);
+};
+const removeNodeById = (document, nodeId) => {
+	if (document.root.id === nodeId) return Result.err([diagnostic("op-root-target", "the document root cannot be removed")]);
+	if (findElement(document.root, nodeId) === null) return Result.err([diagnostic("op-target-not-found", `node "${nodeId}" was not found in the current source`)]);
+	const prune = (node) => {
+		if (node.kind !== "element") return node;
+		return {
+			...node,
+			children: node.children.filter((child) => !(child.kind === "element" && child.id === nodeId)).map(prune)
+		};
+	};
+	return Result.ok({
+		...document,
+		root: prune(document.root)
+	});
+};
+const isDescendant = (ancestor, nodeId) => ancestor.children.some((child) => {
+	if (child.kind !== "element") return false;
+	return child.id === nodeId || isDescendant(child, nodeId);
+});
+const removeElement = (node, nodeId) => {
+	let removed = null;
+	const children = [];
+	for (const child of node.children) {
+		if (child.kind === "element" && child.id === nodeId) {
+			removed = child;
+			continue;
+		}
+		if (child.kind === "element") {
+			const result = removeElement(child, nodeId);
+			if (result.removed !== null) removed = result.removed;
+			children.push(result.node);
+		} else children.push(child);
+	}
+	return {
+		node: {
+			...node,
+			children
+		},
+		removed
+	};
+};
+const insertIntoParent = (node, targetParentId, insertionIndex, moved) => {
+	if (node.id === targetParentId) {
+		const at = elementChildIndexToNodeIndex(node.children, insertionIndex);
+		return {
+			...node,
+			children: [
+				...node.children.slice(0, at),
+				moved,
+				...node.children.slice(at)
+			]
+		};
+	}
+	return {
+		...node,
+		children: node.children.map((child) => child.kind === "element" ? insertIntoParent(child, targetParentId, insertionIndex, moved) : child)
+	};
+};
+const moveNode = (document, op) => {
+	if (document.root.id === op.nodeId) return Result.err([diagnostic("op-root-target", "the document root cannot be moved")]);
+	const moved = findElement(document.root, op.nodeId);
+	if (moved === null) return Result.err([diagnostic("op-target-not-found", `node "${op.nodeId}" was not found in the current source`)]);
+	const parent = findElement(document.root, op.targetParentId);
+	if (parent === null) return Result.err([diagnostic("op-target-not-found", `target parent "${op.targetParentId}" was not found in the current source`)]);
+	if (moved.id === parent.id || isDescendant(moved, parent.id)) return Result.err([diagnostic("op-invalid-reparent", "a node cannot be moved into itself or its descendants")]);
+	const channel = documentChannel(document);
+	const childModel = CHANNEL_TAG_SPECS[channel][parent.tag]?.content;
+	if (!(childModel === void 0 ? [] : allowedChildren(childModel)).includes(moved.tag)) return Result.err([diagnostic("op-invalid-reparent", `<${moved.tag}> is not allowed directly inside <${parent.tag}>`, parent.span)]);
+	const { node: rootWithoutMoved, removed } = removeElement(document.root, op.nodeId);
+	if (removed === null) return Result.err([diagnostic("op-target-not-found", `node "${op.nodeId}" was not found in the current source`)]);
+	return Result.ok({
+		...document,
+		root: insertIntoParent(rootWithoutMoved, op.targetParentId, op.insertionIndex, removed)
+	});
+};
+const duplicateNode = (document, nodeId) => {
+	if (document.root.id === nodeId) return Result.err([diagnostic("op-root-target", "the document root cannot be duplicated")]);
+	if (findElement(document.root, nodeId) === null) return Result.err([diagnostic("op-target-not-found", `node "${nodeId}" was not found in the current source`)]);
+	const insertClone = (node) => {
+		if (node.kind !== "element") return node;
+		const index = node.children.findIndex((child) => child.kind === "element" && child.id === nodeId);
+		if (index >= 0) {
+			const clone = cloneSubtree(node.children[index]);
+			return {
+				...node,
+				children: [
+					...node.children.slice(0, index + 1),
+					clone,
+					...node.children.slice(index + 1)
+				]
+			};
+		}
+		return {
+			...node,
+			children: node.children.map(insertClone)
+		};
+	};
+	return Result.ok({
+		...document,
+		root: insertClone(document.root)
+	});
+};
+const mutate = (document, op) => {
+	switch (op.type) {
+		case "setProp": return setProp(document, op);
+		case "setChildren": return setChildren(document, op);
+		case "insertBlock": return insertBlock(document, op);
+		case "insertSnippet": return insertSnippet(document, op);
+		case "moveNode": return moveNode(document, op);
+		case "duplicateNode": return duplicateNode(document, op.nodeId);
+		case "removeNode": return removeNodeById(document, op.nodeId);
+	}
+};
+const preflight = (source) => {
+	const reparsed = parseSml(source);
+	if (Result.isError(reparsed)) return Result.err(reparsed.error.diagnostics);
+	const compiled = compileSml(reparsed.value);
+	if (Result.isError(compiled)) return Result.err(compiled.error.diagnostics);
+	const compatibilityErrors = checkSmlCompatibility({ source }).filter(isBreakingCompatibilityCheck).map((message) => diagnostic("compatibility-error", message));
+	if (compatibilityErrors.length > 0) return Result.err(compatibilityErrors);
+	return Result.ok(reparsed.value);
+};
+const failedResult = (index, op, diagnostics) => ({
+	index,
+	status: "failed",
+	op,
+	diagnostics: [...diagnostics]
+});
+/**
+* Apply a batch of ops to SML source, returning the rewritten source, its new
+* revision, and a per-op result.
+*
+* Id contract: every id in the batch resolves against the id-space of the
+* source the caller read (the `expectedRevision` snapshot). Ids are positional
+* (`n0..nN` in document order) and are NOT rewritten between ops, so:
+*
+* - An op cannot target a node created earlier in the same batch — freshly
+*   inserted/duplicated nodes carry a blank id until the next reprint reassigns
+*   positional ids, and are unaddressable within the batch (fails with
+*   `op-target-not-found`).
+* - After `duplicateNode`, the duplicated id still addresses the ORIGINAL (the
+*   first match in document order); the clone is a blank-id copy.
+* - Structural ops (insert/remove/move) do not shift the ids of the nodes that
+*   survive, so a later op targeting a surviving sibling lands on the intended
+*   node regardless of what earlier ops did.
+*
+* Each op is still preflighted (reprint, reparse, compile, compatibility check)
+* as an independent validity gate; a failing op is recorded as `failed` and
+* does not advance the working document.
+*/
+const applyOps = (source, ops, options) => {
+	const parsed = parseSml(source);
+	if (Result.isError(parsed)) return Result.err(new SmlOpError({ diagnostics: parsed.error.diagnostics }));
+	const currentRevision = String(options?.currentRevision ?? sourceRevision(source));
+	if (options?.expectedRevision !== void 0 && String(options.expectedRevision) !== currentRevision) {
+		const stale = diagnostic("stale-revision", `source revision changed from ${String(options.expectedRevision)} to ${currentRevision}`);
+		return Result.ok({
+			source,
+			revision: currentRevision,
+			diagnostics: [stale],
+			results: ops.map((op, index) => failedResult(index, op, [stale]))
+		});
+	}
+	let currentSource = source;
+	let currentDocument = parsed.value;
+	const results = [];
+	const diagnostics = [];
+	ops.forEach((op, index) => {
+		const mutated = mutate(currentDocument, op);
+		if (Result.isError(mutated)) {
+			results.push(failedResult(index, op, mutated.error));
+			diagnostics.push(...mutated.error);
+			return;
+		}
+		const candidateSource = printSml(mutated.value);
+		const checked = preflight(candidateSource);
+		if (Result.isError(checked)) {
+			results.push(failedResult(index, op, checked.error));
+			diagnostics.push(...checked.error);
+			return;
+		}
+		currentSource = candidateSource;
+		currentDocument = mutated.value;
+		results.push({
+			index,
+			status: "applied",
+			op,
+			diagnostics: []
+		});
+	});
+	return Result.ok({
+		source: currentSource,
+		revision: sourceRevision(currentSource),
+		diagnostics,
+		results
+	});
+};
+const applyOp = (source, op, options) => applyOps(source, [op], options);
+//#endregion
+export { sourceRevision as a, normalizeSml as i, applyOp as n, applyOps as r, SmlOpError as t };
+
+//# sourceMappingURL=ops-2aiiYO7m.js.map