{feature} try to retain the original in serialization

bgotink · bgotink · commit 35238aab0c58 · 2025-04-28T23:41:03.000+02:00
Try to retain the original order of entries when serializing
an element that came from deserialization.
This only applies to entries, not children, because the order
of children might matter.

The original order of properties is retained completely.
The order of arguments cannot be, for the simple reason that
the order of arguments is likely to be significant.
The interleaving of properties and arguments is retained.
diff --git a/src/dessert/serialization/serialize.js b/src/dessert/serialization/serialize.js
@@ -59,6 +59,11 @@ export function serialize(name, serializer, ...parameters) {
 	/** @type {import("../deserialization/types.js").DeserializationContext | null | undefined} */
 	let source;
 
+	/** @type {Entry[]} */
+	let entries = [];
+	/** @type {Set<Entry>} */
+	let entriesToRemove = new Set();
+
 	/** @type {Entry[]} */
 	let existingArguments = [];
 	/** @type {Map<string, Entry>} */
@@ -76,7 +81,7 @@ export function serialize(name, serializer, ...parameters) {
 				throw new Error("The source function can only be called once");
 			}
 
-			if (node.entries.length || node.hasChildren()) {
+			if (entries.length || node.hasChildren()) {
 				throw new Error(
 					"The source function can only be called at the start of a serialize function",
 				);
@@ -91,8 +96,14 @@ export function serialize(name, serializer, ...parameters) {
 			node = sourceNode.clone({shallow: true});
 			node.setName(typeof name === "string" ? name : "-");
 
-			existingArguments = sourceNode.getArgumentEntries();
-			existingProperties = sourceNode.getPropertyEntryMap();
+			entries = sourceNode.entries.map((entry) => entry.clone());
+			entriesToRemove = new Set(entries);
+			existingArguments = entries.filter((entry) => entry.name == null);
+			existingProperties = new Map(
+				entries.flatMap((entry) =>
+					entry.name ? [[entry.name.name, entry]] : [],
+				),
+			);
 		},
 
 		argument: tagged((tag, value) => {
@@ -102,16 +113,17 @@ export function serialize(name, serializer, ...parameters) {
 				);
 			}
 
-			let argument = existingArguments.shift()?.clone();
+			let argument = existingArguments.shift();
 
 			if (argument) {
+				entriesToRemove.delete(argument);
 				argument.setValue(value);
 			} else {
 				argument = Entry.createArgument(value);
+				entries.push(argument);
 			}
 
 			argument.setTag(tag);
-			node.entries.push(argument);
 		}),
 
 		property: tagged((tag, key, value) => {
@@ -121,16 +133,17 @@ export function serialize(name, serializer, ...parameters) {
 				);
 			}
 
-			let property = existingProperties.get(key)?.clone();
+			let property = existingProperties.get(key);
 
 			if (property) {
+				entriesToRemove.delete(property);
 				property.setValue(value);
 			} else {
 				property = Entry.createProperty(key, value);
+				entries.push(property);
 			}
 
 			property.setTag(tag);
-			node.entries.push(property);
 		}),
 
 		child: /** @type {t.SerializationContext["child"]} */ (
@@ -150,6 +163,12 @@ export function serialize(name, serializer, ...parameters) {
 		),
 
 		json(value) {
+			// We don't properly keep track of property / argument order yet in serializeJson
+			entries = node.entries = entries.filter(
+				(entry) => !entriesToRemove.has(entry),
+			);
+			entriesToRemove = new Set();
+
 			serializeJson(
 				!isSerializingDocument,
 				value,
@@ -167,6 +186,8 @@ export function serialize(name, serializer, ...parameters) {
 	// @ts-expect-error If only typescript supported @overload with rest parameters
 	run(serializer, ...parameters);
 
+	node.entries = entries.filter((entry) => !entriesToRemove.has(entry));
+
 	return typeof name !== "string" ? (node.children ?? new Document()) : node;
 }
 
diff --git a/test/dessert/serialize.js b/test/dessert/serialize.js
@@ -1,10 +1,10 @@
 import assert from "node:assert/strict";
 import {test} from "uvu";
 
-import {concat, serialize} from "../../src/dessert.js";
+import {concat, deserialize, serialize} from "../../src/dessert.js";
 import {clearFormat, format, parse} from "../../src/index.js";
 
-/** @import {SerializationContext} from "../../src/dessert.js"; */
+/** @import {DeserializationContext, SerializationContext} from "../../src/dessert.js"; */
 /** @import {JsonValue} from "../../src/json.js"; */
 
 test("simple", () => {
@@ -58,4 +58,63 @@ node type=json 0 1 2
 	);
 });
 
+test("order of properties", () => {
+	class Test {
+		/** @type {DeserializationContext} */
+		#ctx;
+
+		first;
+		second;
+
+		/**
+		 * @param {string} first
+		 * @param {string} second
+		 */
+		constructor(first, second) {
+			this.first = first;
+			this.second = second;
+		}
+
+		/** @param {DeserializationContext} ctx */
+		static deserialize(ctx) {
+			const value = new Test(
+				ctx.property.required("first", "string"),
+				ctx.property.required("second", "string"),
+			);
+			value.#ctx = ctx;
+			return value;
+		}
+
+		/** @param {SerializationContext} ctx */
+		serialize(ctx) {
+			ctx.source(this.#ctx);
+
+			ctx.property("first", this.first);
+			ctx.property("second", this.second);
+		}
+	}
+
+	let node = parse(`node first=first second=second;`, {as: "node"});
+	let test = deserialize(node, Test);
+
+	test.second = "first";
+	test.first = "second";
+
+	assert.equal(
+		format(serialize("node", test)),
+		"node first=second second=first;",
+	);
+
+	node = parse(`node second=second first=first;`, {as: "node"});
+	test = deserialize(node, Test);
+
+	test.second = "first";
+	test.first = "second";
+
+	assert.equal(
+		format(serialize("node", test)),
+		"node second=first first=second;",
+	);
+});
+
 test.run();
