bireactive 0.3.3 → 0.3.4

package/dist/automerge/doc-cell.d.ts

@@ -1,11 +1,15 @@
 import type { DocHandle } from "@automerge/automerge-repo";
 import { type Cell, type Writable } from "../core/cell.js";
 import { type Store } from "../core/store.js";
-import { type By } from "./reconcile.js";
+import { type By, type Replace } from "./reconcile.js";
 /** Bridge options shared by every `connect*` entry. */
 export interface DocOptions {
     /** Identity key for list elements, enabling keyed reconciliation (see `reconcile`). */
     by?: By;
+    /** Keys whose values are written wholesale (a `put`) rather than deep-merged —
+     *  for opaque blobs a downstream bridge can only apply as whole-object puts
+     *  (see `reconcile`'s `Replace`). */
+    replace?: Replace;
 }
 /** Lifecycle shared by every bridge: retarget the doc, detach both directions. */
 export interface DocLifecycle<T> {

package/dist/automerge/doc-cell.js

@@ -39,14 +39,14 @@ function deepEqual(a, b) {
     return true;
 }
 /** Wire an existing cell to a handle in both directions; returns an unbind. */
-function bind(c, handle, by) {
+function bind(c, handle, by, replace) {
     const onChange = () => {
         c.value = structuredClone(handle.doc());
     };
     handle.on("change", onChange);
     const stop = effect(() => {
         const next = c.value;
-        handle.change((d) => reconcile(d, next, by));
+        handle.change((d) => reconcile(d, next, by, replace));
     });
     return () => {
         stop();
@@ -56,8 +56,9 @@ function bind(c, handle, by) {
 /** Core: a doc-backed cell plus lifecycle. The cell projections layer on top. */
 function connect(handle, opts) {
     const by = opts?.by;
+    const replace = opts?.replace;
     const c = cell(structuredClone(handle.doc()), { equals: deepEqual, name: "doc" });
-    let unbind = bind(c, handle, by);
+    let unbind = bind(c, handle, by, replace);
     return {
         cell: c,
         retarget: next => {
@@ -65,7 +66,7 @@ function connect(handle, opts) {
             // Seed the cell from the new doc *before* re-binding, so the cell→doc
             // effect doesn't push the old value into the freshly targeted doc.
             c.value = structuredClone(next.doc());
-            unbind = bind(c, next, by);
+            unbind = bind(c, next, by, replace);
         },
         dispose: () => unbind(),
     };

package/dist/automerge/index.d.ts

@@ -1,4 +1,4 @@
 export type { CellBridge, DocBridge, DocLifecycle, DocOptions, StoreBridge } from "./doc-cell.js";
 export { connectCell, connectDoc, connectStore } from "./doc-cell.js";
-export type { By } from "./reconcile.js";
+export type { By, Replace } from "./reconcile.js";
 export { reconcile } from "./reconcile.js";

package/dist/automerge/reconcile.d.ts

@@ -2,7 +2,16 @@ type Any = any;
 /** Stable identity key for a list element; return a primitive. `undefined` (or a
  *  collision) on any element makes that list fall back to positional. */
 export type By = (element: unknown) => unknown;
+/** Predicate over an object key (or list index): return `true` to *replace* that
+ *  field's value wholesale (a scalar assignment → an Automerge `put`) instead of
+ *  recursively merging into it. Use this for opaque JSON blobs that a downstream
+ *  bridge can only consume as whole-object puts — e.g. tldraw's `richText`, whose
+ *  patch applier rejects nested text `splice`s and mis-reads nested `del`s. The
+ *  value is still only written when it actually differs, so unrelated commits
+ *  don't churn it. */
+export type Replace = (key: string | number) => boolean;
 /** Minimally mutate the Automerge node `target` (inside `handle.change`) to equal
- *  the plain value `next`. Pass `by` for identity-keyed list reconciliation. */
-export declare function reconcile(target: Any, next: Any, by?: By): void;
+ *  the plain value `next`. Pass `by` for identity-keyed list reconciliation, and
+ *  `replace` to assign chosen keys wholesale instead of merging into them. */
+export declare function reconcile(target: Any, next: Any, by?: By, replace?: Replace): void;
 export {};

package/dist/automerge/reconcile.js

@@ -17,27 +17,63 @@
 // splices/inserts for the rest, so reorders and mid-inserts merge cleanly.
 import { updateText } from "@automerge/automerge-repo";
 const isPlainObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+/** Structural equality, used to skip a wholesale `replace` write when the field
+ *  is already deep-equal (so reconciling an unrelated change doesn't rewrite it).
+ *  Note `a` may be a live Automerge proxy: its *lists* don't expose indices via
+ *  `Object.keys`, so arrays are walked by length/index, not key enumeration. */
+function deepEq(a, b) {
+    if (Object.is(a, b))
+        return true;
+    if (a === null || b === null || typeof a !== "object" || typeof b !== "object")
+        return false;
+    const aArr = Array.isArray(a);
+    if (aArr !== Array.isArray(b))
+        return false;
+    if (aArr) {
+        const av = a;
+        const bv = b;
+        if (av.length !== bv.length)
+            return false;
+        for (let i = 0; i < av.length; i++)
+            if (!deepEq(av[i], bv[i]))
+                return false;
+        return true;
+    }
+    const ak = Object.keys(a);
+    const bk = Object.keys(b);
+    if (ak.length !== bk.length)
+        return false;
+    for (const k of ak) {
+        if (!Object.hasOwn(b, k))
+            return false;
+        if (!deepEq(a[k], b[k]))
+            return false;
+    }
+    return true;
+}
 /** Minimally mutate the Automerge node `target` (inside `handle.change`) to equal
- *  the plain value `next`. Pass `by` for identity-keyed list reconciliation. */
-export function reconcile(target, next, by) {
+ *  the plain value `next`. Pass `by` for identity-keyed list reconciliation, and
+ *  `replace` to assign chosen keys wholesale instead of merging into them. */
+export function reconcile(target, next, by, replace) {
+    const ctx = { by, replace };
     if (Array.isArray(next) && Array.isArray(target))
-        reconcileList(target, next, by);
+        reconcileList(target, next, ctx);
     else
-        reconcileObject(target, next, by);
+        reconcileObject(target, next, ctx);
 }
-function reconcileObject(target, next, by) {
+function reconcileObject(target, next, ctx) {
     for (const k of Object.keys(target))
         if (!(k in next))
             delete target[k];
     for (const k of Object.keys(next))
-        setKey(target, k, target[k], next[k], false, by);
+        setKey(target, k, target[k], next[k], false, ctx);
 }
-function reconcileList(target, next, by) {
-    if (by !== undefined && reconcileKeyed(target, next, by))
+function reconcileList(target, next, ctx) {
+    if (ctx.by !== undefined && reconcileKeyed(target, next, ctx))
         return;
     const shared = Math.min(target.length, next.length);
     for (let i = 0; i < shared; i++)
-        setKey(target, i, target[i], next[i], true, by);
+        setKey(target, i, target[i], next[i], true, ctx);
     if (next.length < target.length)
         target.splice(next.length);
     else
@@ -46,7 +82,8 @@ function reconcileList(target, next, by) {
 }
 /** Keyed list reconcile via LCS. Returns false (→ positional fallback) when keys
  *  aren't total + unique on either side. */
-function reconcileKeyed(target, next, by) {
+function reconcileKeyed(target, next, ctx) {
+    const by = ctx.by;
     const tKeys = target.map(by);
     const nKeys = next.map(by);
     if (!totalUnique(tKeys) || !totalUnique(nKeys))
@@ -57,7 +94,7 @@ function reconcileKeyed(target, next, by) {
         if (keep.has(nKeys[n])) {
             while (i < target.length && !keep.has(by(target[i])))
                 target.splice(i, 1);
-            setKey(target, i, target[i], next[n], true, by); // same identity → merge edits
+            setKey(target, i, target[i], next[n], true, ctx); // same identity → merge edits
             i++;
         }
         else {
@@ -98,7 +135,16 @@ function lcs(a, b) {
     }
     return keep;
 }
-function setKey(parent, key, a, b, inList, by) {
+function setKey(parent, key, a, b, inList, ctx) {
+    // Wholesale-replace keys bypass the merge entirely: assign the value so
+    // Automerge emits a single `put` of the (re)built subtree — no nested text
+    // `splice`s, no `del`s — which is all some bridges can apply. Guard on
+    // deep-equality so reconciling an unrelated change doesn't rewrite it.
+    if (ctx.replace?.(key)) {
+        if (!deepEq(a, b))
+            parent[key] = b;
+        return;
+    }
     if (typeof b === "string" && typeof a === "string") {
         // Char-level merge for object text fields; list string elements just assign
         // (path-relative updateText targets a keyed field, not an array slot).
@@ -110,10 +156,10 @@ function setKey(parent, key, a, b, inList, by) {
         }
     }
     else if (Array.isArray(b) && Array.isArray(a)) {
-        reconcileList(a, b, by);
+        reconcileList(a, b, ctx);
     }
     else if (isPlainObject(b) && isPlainObject(a)) {
-        reconcileObject(a, b, by);
+        reconcileObject(a, b, ctx);
     }
     else if (a !== b) {
         parent[key] = b;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bireactive",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "description": "Bi-directional reactive programming.",
   "type": "module",
   "main": "./dist/index.js",