@gogitcms/design-system 0.16.0-next.1 → 0.16.0-next.11

package/src/components/CollabField.tsx

@@ -386,3 +386,74 @@ export function CollabTextarea({
     </PresenceField>
   );
 }
+
+// ---- writing a whole value into the shared document ------------------------
+
+/**
+ * Where one leaf of a document value lives in the shared doc.
+ *
+ * The split mirrors what the server seeds (collab.go's collectLeaves), because
+ * that is what decides which binding a control actually reads: a string is a
+ * Y.Text, and everything else — numbers, booleans, null, and whole lists — is a
+ * key in the "reg" map. Writing to the other one is not an error anyone sees;
+ * it is a value that silently lands where nothing is looking.
+ */
+type CollabLeaf = { kind: "text"; value: string } | { kind: "reg"; value: unknown };
+
+/**
+ * Flattens a value into the leaves the shared document holds it as, keyed by
+ * dotted path — `seo.title` for a group's child, exactly as the server does.
+ *
+ * `undefined` yields no leaves at all: it means the field is absent, which is
+ * expressed by clearing whatever was there rather than by writing something.
+ */
+function collabLeaves(path: string, value: unknown, into = new Map<string, CollabLeaf>()): Map<string, CollabLeaf> {
+  if (value === undefined) return into;
+  if (typeof value === "string") {
+    into.set(path, { kind: "text", value });
+    return into;
+  }
+  // A list is a whole-value register, matching CollabArrayField — its items are
+  // not addressable leaves, so it is written and cleared in one piece.
+  if (Array.isArray(value) || value === null || typeof value !== "object") {
+    into.set(path, { kind: "reg", value });
+    return into;
+  }
+  for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+    collabLeaves(path ? `${path}.${k}` : k, v, into);
+  }
+  return into;
+}
+
+/**
+ * Replaces a field's value in the shared document, so a value written by
+ * something other than typing — restoring a field from a past version — reaches
+ * the room instead of only the local form.
+ *
+ * In a live session the shared document is the source of truth: every collab
+ * control reads its binding in preference to the host's value, so a write that
+ * only touches local state is displayed for an instant and then overwritten by
+ * the CRDT's unchanged value. It has to be written here to be written at all.
+ *
+ * `previous` is what the field held, and is needed rather than inferable: the
+ * new value's leaves say what to write, but only the old value's leaves say
+ * what to CLEAR — a group that loses a child, or a field being cleared outright,
+ * would otherwise keep the shared value nobody can see any more.
+ */
+export function writeCollabValue(collab: CollabApi, path: string, previous: unknown, next: unknown): void {
+  const before = collabLeaves(path, previous);
+  const after = collabLeaves(path, next);
+
+  for (const [leafPath, leaf] of before) {
+    if (after.has(leafPath)) continue;
+    // Clearing is per shared type: a Y.Text empties, a register goes back to
+    // unset (which is what an absent key reads as, and what makes the control
+    // fall back to the document's own value).
+    if (leaf.kind === "text") collab.text(leafPath).set("");
+    else collab.register(leafPath).set(undefined);
+  }
+  for (const [leafPath, leaf] of after) {
+    if (leaf.kind === "text") collab.text(leafPath).set(leaf.value);
+    else collab.register(leafPath).set(leaf.value);
+  }
+}