doxum 0.1.3 → 0.1.5

package/dist/index.cjs

@@ -196,7 +196,11 @@ const writerFor = (node, inputAddress, sink) => {
 			type: "dict.replace",
 			at: address,
 			value
-		})
+		}),
+		...node.optional ? { clear: () => emit(sink, {
+			type: "value.clear",
+			at: address
+		}) } : {}
 	};
 	if (node.kind === "list") return {
 		insert: (value, anchor) => emit(sink, {
@@ -222,7 +226,11 @@ const writerFor = (node, inputAddress, sink) => {
 			at: address,
 			value,
 			keys: value.map(node.keyOf)
-		})
+		}),
+		...node.optional ? { clear: () => emit(sink, {
+			type: "value.clear",
+			at: address
+		}) } : {}
 	};
 	if (node.kind === "tree") return {
 		insert: (treeNodeId, value, parentId, index) => emit(sink, {
@@ -255,7 +263,11 @@ const writerFor = (node, inputAddress, sink) => {
 			type: "tree.replace",
 			at: address,
 			value
-		})
+		}),
+		...node.optional ? { clear: () => emit(sink, {
+			type: "value.clear",
+			at: address
+		}) } : {}
 	};
 	if (node.kind === "table") {
 		let items;
@@ -319,11 +331,17 @@ const writerFor = (node, inputAddress, sink) => {
 		};
 	}
 	if (node.kind === "single") return writerFor(node.value, address, sink);
-	if (node.kind === "variant") return { replace: (value) => emit(sink, {
-		type: "variant.replace",
-		at: address,
-		value
-	}) };
+	if (node.kind === "variant") return {
+		replace: (value) => emit(sink, {
+			type: "variant.replace",
+			at: address,
+			value
+		}),
+		...node.optional ? { clear: () => emit(sink, {
+			type: "value.clear",
+			at: address
+		}) } : {}
+	};
 	let children;
 	return new Proxy({}, { get: (_target, property) => {
 		if (typeof property !== "string" || !node.shape[property]) return void 0;
@@ -541,8 +559,11 @@ const rejected$3 = (operation, code, message) => ({
 	issue: from(operation, code, message)
 });
 const executeList = (target, operation, copyPayload) => {
-	if (!Array.isArray(target.value) || target.node.kind !== "list") return rejected$3(operation, "invalid-address", "List target is invalid.");
-	const list = target.value;
+	if (target.node.kind !== "list") return rejected$3(operation, "invalid-address", "List target is invalid.");
+	const absent = target.value === void 0 && "optional" in target.node && target.node.optional === true;
+	if (!Array.isArray(target.value) && !absent) return rejected$3(operation, "invalid-address", "List target is invalid.");
+	if (absent && operation.type !== "list.replace") return rejected$3(operation, "invalid-address", "Only list replacement can initialize an optional list.");
+	const list = Array.isArray(target.value) ? target.value : [];
 	const orderedKeys = keys(list, target.node.keyOf);
 	const own = (value) => copyPayload ? require_ownership.ownPayload(value) : value;
 	if (operation.type === "list.replace") {
@@ -553,18 +574,23 @@ const executeList = (target, operation, copyPayload) => {
 			if (seen.has(key) || target.node.keyOf(operation.value[index]) !== key) return rejected$3(operation, "invalid-list-keys", "List replacement keys are invalid.");
 			seen.add(key);
 		}
-		if (require_ownership.sameStructuralValue(list, operation.value)) return { status: "unchanged" };
-		const keys = new Array(list.length);
-		for (let index = 0; index < list.length; index += 1) keys[index] = target.node.keyOf(list[index]);
-		const inverse = {
+		if (!absent && require_ownership.sameStructuralValue(list, operation.value)) return { status: "unchanged" };
+		const keys = list.map(target.node.keyOf);
+		const inverse = absent ? {
+			type: "value.clear",
+			at: operation.at
+		} : {
 			type: "list.replace",
 			at: operation.at,
 			value: require_ownership.cloneValue(list, "inverse"),
 			keys
 		};
 		const owned = own(operation.value);
-		list.length = owned.length;
-		for (let index = 0; index < owned.length; index += 1) list[index] = owned[index];
+		if (absent) target.parent[target.key] = owned;
+		else {
+			list.length = owned.length;
+			for (let index = 0; index < owned.length; index += 1) list[index] = owned[index];
+		}
 		return {
 			status: "changed",
 			inverse: [inverse]
@@ -1024,16 +1050,39 @@ const outcome = (operation, value) => value.status === "rejected" ? {
 	issue: from(operation, value.code, value.message)
 } : value;
 const executeTree = (root, target, operation, copyPayload) => {
-	if (!is(target.value)) return {
+	if (target.node.kind !== "tree") return {
 		status: "rejected",
 		issue: from(operation, "invalid-address", "Tree target is invalid.")
 	};
 	const own = (value) => copyPayload ? require_ownership.ownPayload(value) : value;
+	const absent = target.value === void 0 && "optional" in target.node && target.node.optional === true;
 	if (operation.type === "tree.replace") {
+		if (absent) {
+			if (!validate(operation.value)) return {
+				status: "rejected",
+				issue: from(operation, "invalid-tree", "Tree replacement is malformed.")
+			};
+			target.parent[target.key] = own(operation.value);
+			return {
+				status: "changed",
+				inverse: [{
+					type: "value.clear",
+					at: operation.at
+				}]
+			};
+		}
+		if (!is(target.value)) return {
+			status: "rejected",
+			issue: from(operation, "invalid-address", "Tree target is invalid.")
+		};
 		const result = replace(target.value, operation);
 		if (result.status === "changed") require_dependency.set(root, operation.at, require_ownership.ownPayload(operation.value));
 		return outcome(operation, result);
 	}
+	if (!is(target.value)) return {
+		status: "rejected",
+		issue: from(operation, "invalid-address", "Tree target is invalid.")
+	};
 	if (operation.type === "tree.insert") return outcome(operation, insert(target.value, operation, own(operation.value)));
 	if (operation.type === "tree.set") return outcome(operation, set(target.value, operation, own(operation.value)));
 	if (operation.type === "tree.remove") return outcome(operation, remove(target.value, operation));
@@ -1091,6 +1140,18 @@ const executeValue = (target, operation, copyPayload) => {
 			inverse: [inverse]
 		};
 	}
+	if (operation.type === "dict.replace" && target.value === void 0) {
+		if (!("optional" in target.node) || !target.node.optional) return rejected$1(operation, "invalid-address", "Dictionary target is invalid.");
+		const inverse = {
+			type: "value.clear",
+			at: operation.at
+		};
+		target.parent[target.key] = own(operation.value);
+		return {
+			status: "changed",
+			inverse: [inverse]
+		};
+	}
 	if (!require_ownership.isRecord(target.value)) return rejected$1(operation, "invalid-address", "Dictionary target is invalid.");
 	if (operation.type === "dict.replace") {
 		if (require_ownership.sameStructuralValue(target.value, operation.value)) return { status: "unchanged" };
@@ -1139,11 +1200,67 @@ const executeValue = (target, operation, copyPayload) => {
 };
 //#endregion
 //#region core/src/mutation/execute.ts
+const hasOwn$1 = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+const executeClear = (target, operation) => {
+	if (!("optional" in target.node) || !target.node.optional) return {
+		status: "rejected",
+		issue: from(operation, "required-field", "Only optional values can be cleared.")
+	};
+	if (!hasOwn$1(target.parent, target.key)) return { status: "unchanged" };
+	if (target.node.kind !== "field" && target.node.kind !== "variant" && target.node.kind !== "dict" && target.node.kind !== "record" && target.node.kind !== "list" && target.node.kind !== "tree") return {
+		status: "rejected",
+		issue: from(operation, "invalid-operation", "This optional value has no clear operation.")
+	};
+	const inverse = (() => {
+		switch (target.node.kind) {
+			case "field": return {
+				type: "field.set",
+				at: operation.at,
+				value: target.value
+			};
+			case "variant": return {
+				type: "variant.replace",
+				at: operation.at,
+				value: require_ownership.cloneValue(target.value, "inverse")
+			};
+			case "dict":
+			case "record": return {
+				type: "dict.replace",
+				at: operation.at,
+				value: require_ownership.cloneValue(target.value, "inverse")
+			};
+			case "list":
+				if (!Array.isArray(target.value)) return {
+					type: "list.replace",
+					at: operation.at,
+					value: [],
+					keys: []
+				};
+				return {
+					type: "list.replace",
+					at: operation.at,
+					value: require_ownership.cloneValue(target.value, "inverse"),
+					keys: target.value.map(target.node.keyOf)
+				};
+			case "tree": return {
+				type: "tree.replace",
+				at: operation.at,
+				value: require_ownership.cloneValue(target.value, "inverse")
+			};
+		}
+	})();
+	delete target.parent[target.key];
+	return {
+		status: "changed",
+		inverse: [inverse]
+	};
+};
 const invalidTarget = (operation) => ({
 	status: "rejected",
 	issue: from(operation, "invalid-address", `Operation '${operation.type}' does not match the schema address.`)
 });
 const execute = (root, operation, target, copyPayload) => {
+	if (operation.type === "value.clear") return !target ? invalidTarget(operation) : executeClear(target, operation);
 	if (operation.type === "field.set" || operation.type === "field.clear") return !target || target.node.kind !== "field" ? invalidTarget(operation) : executeValue(target, operation, copyPayload);
 	if (operation.type === "variant.replace") return !target || target.node.kind !== "variant" ? invalidTarget(operation) : executeValue(target, operation, copyPayload);
 	if (operation.type === "dict.set" || operation.type === "dict.delete" || operation.type === "dict.replace") return !target || target.node.kind !== "dict" && target.node.kind !== "record" ? invalidTarget(operation) : executeValue(target, operation, copyPayload);
@@ -1533,11 +1650,12 @@ const createChangeJournal = (root) => {
 	const recordValue = (resolved, operation, inverse) => {
 		if (find("value", operation.at, resolved.addressHash)) return;
 		const first = inverse[0];
-		if (first?.type !== "field.set" && first?.type !== "field.clear") return inverseMismatch(operation);
+		if (first?.type !== "field.set" && first?.type !== "field.clear" && first?.type !== "value.clear" && !("value" in (first ?? {}))) return inverseMismatch(operation);
+		const before = first.type === "field.clear" || first.type === "value.clear" ? absent : "value" in first ? present(first.value) : inverseMismatch(operation);
 		add({
 			...base(resolved, operation),
 			kind: "value",
-			before: first.type === "field.set" ? present(first.value) : absent
+			before
 		});
 	};
 	const recordVariant = (resolved, operation, inverse) => {
@@ -1580,6 +1698,18 @@ const createChangeJournal = (root) => {
 		if (!first) return inverseMismatch(operation);
 		let subject = find("list", operation.at, resolved.addressHash);
 		if (!subject) {
+			if (first.type === "value.clear") {
+				add({
+					...base(resolved, operation),
+					kind: "list",
+					node: resolved.node,
+					state: {
+						mode: "whole",
+						value: void 0
+					}
+				});
+				return;
+			}
 			if (first.type === "list.replace") {
 				add({
 					...base(resolved, operation),
@@ -1667,6 +1797,22 @@ const createChangeJournal = (root) => {
 	};
 	const recordTree = (resolved, operation, inverse) => {
 		const current = require_dependency.read(root, operation.at);
+		if (inverse.length === 1 && inverse[0].type === "value.clear" && operation.type === "tree.replace") {
+			const subject = find("tree", operation.at, resolved.addressHash);
+			if (subject) subject.state = {
+				mode: "whole",
+				value: void 0
+			};
+			else add({
+				...base(resolved, operation),
+				kind: "tree",
+				state: {
+					mode: "whole",
+					value: void 0
+				}
+			});
+			return;
+		}
 		if (!is(current)) return inverseMismatch(operation);
 		const inverses = inverse.filter(treeOperation);
 		if (inverses.length === 0 || inverses.length !== inverse.length) return inverseMismatch(operation);
@@ -1683,7 +1829,7 @@ const createChangeJournal = (root) => {
 		record: (resolved, operation, inverse) => {
 			require_ownership.profile.batch.journalRecord();
 			if (ownerOf(operation.at)) return;
-			if (operation.type === "field.set" || operation.type === "field.clear") {
+			if (operation.type === "field.set" || operation.type === "field.clear" || operation.type === "value.clear") {
 				recordValue(resolved, operation, inverse);
 				return;
 			}
@@ -1692,7 +1838,8 @@ const createChangeJournal = (root) => {
 				return;
 			}
 			if (operation.type === "dict.set" || operation.type === "dict.delete" || operation.type === "dict.replace") {
-				recordDict(resolved, operation, inverse);
+				if (operation.type === "dict.replace" && inverse[0]?.type === "value.clear") recordValue(resolved, operation, inverse);
+				else recordDict(resolved, operation, inverse);
 				return;
 			}
 			if (operation.type === "entity.create" || operation.type === "entity.remove" || operation.type === "entity.move") {
@@ -1793,7 +1940,8 @@ const decode = (input) => {
 	switch (input.type) {
 		case "field.set":
 		case "variant.replace": return has(input, "value") ? decoded(input) : rejected("invalid-operation", "Operation value is required.");
-		case "field.clear": return decoded(input);
+		case "field.clear":
+		case "value.clear": return decoded(input);
 		case "dict.set": return typeof input.key === "string" && has(input, "value") ? decoded(input) : rejected("invalid-operation", "Dictionary set requires a string key and value.");
 		case "dict.delete": return typeof input.key === "string" ? decoded(input) : rejected("invalid-operation", "Dictionary delete requires a string key.");
 		case "dict.replace": return require_ownership.isRecord(input.value) ? decoded(input) : rejected("invalid-operation", "Dictionary replacement must be an object.");
@@ -1986,6 +2134,7 @@ const commandFootprint = (operations) => {
 	for (const operation of operations) switch (operation.type) {
 		case "field.set":
 		case "field.clear":
+		case "value.clear":
 		case "variant.replace":
 			add(targets, {
 				kind: "value",