@loro-extended/change 0.9.0 → 0.9.1

package/dist/index.js

@@ -143,12 +143,21 @@ function mergeValue(shape, crdtValue, placeholderValue) {
   }
   switch (shape._type) {
     case "text":
-      return crdtValue ?? placeholderValue ?? "";
+      return crdtValue !== void 0 ? crdtValue : placeholderValue ?? "";
     case "counter":
-      return crdtValue ?? placeholderValue ?? 0;
+      return crdtValue !== void 0 ? crdtValue : placeholderValue ?? 0;
     case "list":
-    case "movableList":
-      return crdtValue ?? placeholderValue ?? [];
+    case "movableList": {
+      if (crdtValue === void 0) {
+        return placeholderValue ?? [];
+      }
+      const crdtArray = crdtValue;
+      const itemShape = shape.shape;
+      const itemPlaceholder = deriveShapePlaceholder(itemShape);
+      return crdtArray.map(
+        (item) => mergeValue(itemShape, item, itemPlaceholder)
+      );
+    }
     case "map": {
       if (!isObjectValue(crdtValue) && crdtValue !== void 0) {
         throw new Error("map crdt must be object");
@@ -171,14 +180,31 @@ function mergeValue(shape, crdtValue, placeholderValue) {
       return result;
     }
     case "tree":
-      return crdtValue ?? placeholderValue ?? [];
+      return crdtValue !== void 0 ? crdtValue : placeholderValue ?? [];
+    case "record": {
+      if (!isObjectValue(crdtValue) && crdtValue !== void 0) {
+        throw new Error("record crdt must be object");
+      }
+      const crdtRecordValue = crdtValue ?? {};
+      const result = {};
+      for (const key of Object.keys(crdtRecordValue)) {
+        const nestedCrdtValue = crdtRecordValue[key];
+        const nestedPlaceholderValue = deriveShapePlaceholder(shape.shape);
+        result[key] = mergeValue(
+          shape.shape,
+          nestedCrdtValue,
+          nestedPlaceholderValue
+        );
+      }
+      return result;
+    }
     default:
       if (shape._type === "value" && shape.valueType === "object") {
         const crdtObj = crdtValue ?? {};
         const placeholderObj = placeholderValue ?? {};
         const result = { ...placeholderObj };
         if (typeof crdtObj !== "object" || crdtObj === null) {
-          return crdtValue ?? placeholderValue;
+          return crdtValue !== void 0 ? crdtValue : placeholderValue;
         }
         for (const [key, propShape] of Object.entries(shape.shape)) {
           const propCrdt = crdtObj[key];
@@ -194,7 +220,7 @@ function mergeValue(shape, crdtValue, placeholderValue) {
           placeholderValue
         );
       }
-      return crdtValue ?? placeholderValue;
+      return crdtValue !== void 0 ? crdtValue : placeholderValue;
   }
 }
 function mergeDiscriminatedUnion(shape, crdtValue, placeholderValue) {
@@ -206,7 +232,7 @@ function mergeDiscriminatedUnion(shape, crdtValue, placeholderValue) {
   }
   const variantShape = shape.variants[discriminantValue];
   if (!variantShape) {
-    return crdtValue ?? placeholderValue;
+    return crdtValue !== void 0 ? crdtValue : placeholderValue;
   }
   const placeholderDiscriminant = placeholderObj[shape.discriminantKey];
   const effectivePlaceholderValue = placeholderDiscriminant === discriminantValue ? placeholderValue : void 0;
@@ -678,6 +704,15 @@ var TypedRef = class {
   get readonly() {
     return !!this._params.readonly;
   }
+  /**
+   * Throws an error if this ref is in readonly mode.
+   * Call this at the start of any mutating method.
+   */
+  assertMutable() {
+    if (this.readonly) {
+      throw new Error("Cannot modify readonly ref");
+    }
+  }
   get container() {
     if (!this._cachedContainer) {
       const container = this._params.getContainer();
@@ -688,16 +723,26 @@ var TypedRef = class {
   }
 };
 
+// src/typed-refs/utils.ts
+import {
+  LoroCounter as LoroCounter2,
+  LoroList as LoroList2,
+  LoroMap as LoroMap2,
+  LoroMovableList as LoroMovableList2,
+  LoroText as LoroText2,
+  LoroTree
+} from "loro-crdt";
+
 // src/typed-refs/counter.ts
 var CounterRef = class extends TypedRef {
   absorbPlainValues() {
   }
   increment(value) {
-    if (this.readonly) throw new Error("Cannot modify readonly ref");
+    this.assertMutable();
     this.container.increment(value);
   }
   decrement(value) {
-    if (this.readonly) throw new Error("Cannot modify readonly ref");
+    this.assertMutable();
     this.container.decrement(value);
   }
   get value() {
@@ -732,7 +777,7 @@ function convertListInput(value, shape) {
   }
   const list = new LoroList();
   for (const item of value) {
-    const convertedItem = convertInputToNode(item, shape.shape);
+    const convertedItem = convertInputToRef(item, shape.shape);
     if (isContainer(convertedItem)) {
       list.pushContainer(convertedItem);
     } else {
@@ -747,7 +792,7 @@ function convertMovableListInput(value, shape) {
   }
   const list = new LoroMovableList();
   for (const item of value) {
-    const convertedItem = convertInputToNode(item, shape.shape);
+    const convertedItem = convertInputToRef(item, shape.shape);
     if (isContainer(convertedItem)) {
       list.pushContainer(convertedItem);
     } else {
@@ -764,7 +809,7 @@ function convertMapInput(value, shape) {
   for (const [k, v] of Object.entries(value)) {
     const nestedSchema = shape.shapes[k];
     if (nestedSchema) {
-      const convertedValue = convertInputToNode(v, nestedSchema);
+      const convertedValue = convertInputToRef(v, nestedSchema);
       if (isContainer(convertedValue)) {
         map.setContainer(k, convertedValue);
       } else {
@@ -782,7 +827,7 @@ function convertRecordInput(value, shape) {
   }
   const map = new LoroMap();
   for (const [k, v] of Object.entries(value)) {
-    const convertedValue = convertInputToNode(v, shape.shape);
+    const convertedValue = convertInputToRef(v, shape.shape);
     if (isContainer(convertedValue)) {
       map.setContainer(k, convertedValue);
     } else {
@@ -791,7 +836,7 @@ function convertRecordInput(value, shape) {
   }
   return map;
 }
-function convertInputToNode(value, shape) {
+function convertInputToRef(value, shape) {
   switch (shape._type) {
     case "text": {
       if (typeof value !== "string") {
@@ -868,7 +913,7 @@ var ListRefBase = class extends TypedRef {
     this.itemCache.clear();
   }
   insertWithConversion(index, item) {
-    const convertedItem = convertInputToNode(item, this.shape.shape);
+    const convertedItem = convertInputToRef(item, this.shape.shape);
     if (isContainer(convertedItem)) {
       this.container.insertContainer(index, convertedItem);
     } else {
@@ -876,7 +921,7 @@ var ListRefBase = class extends TypedRef {
     }
   }
   pushWithConversion(item) {
-    const convertedItem = convertInputToNode(item, this.shape.shape);
+    const convertedItem = convertInputToRef(item, this.shape.shape);
     if (isContainer(convertedItem)) {
       this.container.pushContainer(convertedItem);
     } else {
@@ -949,13 +994,10 @@ var ListRefBase = class extends TypedRef {
       );
       this.itemCache.set(index, cachedItem);
       if (this.readonly) {
-        const shape = this.shape.shape;
-        if (shape._type === "counter") {
-          return cachedItem.value;
-        }
-        if (shape._type === "text") {
-          return cachedItem.toString();
-        }
+        return unwrapReadonlyPrimitive(
+          cachedItem,
+          this.shape.shape
+        );
       }
       return cachedItem;
     }
@@ -1033,25 +1075,25 @@ var ListRefBase = class extends TypedRef {
     return result;
   }
   insert(index, item) {
-    if (this.readonly) throw new Error("Cannot modify readonly ref");
+    this.assertMutable();
     this.updateCacheForInsert(index);
     this.insertWithConversion(index, item);
   }
   delete(index, len) {
-    if (this.readonly) throw new Error("Cannot modify readonly ref");
+    this.assertMutable();
     this.updateCacheForDelete(index, len);
     this.container.delete(index, len);
   }
   push(item) {
-    if (this.readonly) throw new Error("Cannot modify readonly ref");
+    this.assertMutable();
     this.pushWithConversion(item);
   }
   pushContainer(container) {
-    if (this.readonly) throw new Error("Cannot modify readonly ref");
+    this.assertMutable();
     return this.container.pushContainer(container);
   }
   insertContainer(index, container) {
-    if (this.readonly) throw new Error("Cannot modify readonly ref");
+    this.assertMutable();
     return this.container.insertContainer(index, container);
   }
   get(index) {
@@ -1065,6 +1107,16 @@ var ListRefBase = class extends TypedRef {
     return result;
   }
   toJSON() {
+    if (this.readonly) {
+      const nativeJson = this.container.toJSON();
+      if (isContainerShape(this.shape.shape) || isValueShape(this.shape.shape) && this.shape.shape.valueType === "object") {
+        const itemPlaceholder = deriveShapePlaceholder(this.shape.shape);
+        return nativeJson.map(
+          (item) => mergeValue(this.shape.shape, item, itemPlaceholder)
+        );
+      }
+      return nativeJson ?? [];
+    }
     return this.toArray();
   }
   [Symbol.iterator]() {
@@ -1122,23 +1174,6 @@ var ListRef = class extends ListRefBase {
 };
 
 // src/typed-refs/map.ts
-import {
-  LoroCounter as LoroCounter2,
-  LoroList as LoroList2,
-  LoroMap as LoroMap2,
-  LoroMovableList as LoroMovableList2,
-  LoroText as LoroText2,
-  LoroTree
-} from "loro-crdt";
-var containerConstructor = {
-  counter: LoroCounter2,
-  list: LoroList2,
-  map: LoroMap2,
-  movableList: LoroMovableList2,
-  record: LoroMap2,
-  text: LoroText2,
-  tree: LoroTree
-};
 var MapRef = class extends TypedRef {
   propertyCache = /* @__PURE__ */ new Map();
   constructor(params) {
@@ -1152,13 +1187,7 @@ var MapRef = class extends TypedRef {
     return super.container;
   }
   absorbPlainValues() {
-    for (const [key, node] of this.propertyCache.entries()) {
-      if (node instanceof TypedRef) {
-        node.absorbPlainValues();
-        continue;
-      }
-      this.container.set(key, node);
-    }
+    absorbCachedPlainValues(this.propertyCache, () => this.container);
   }
   getTypedRefParams(key, shape) {
     const placeholder = this.placeholder?.[key];
@@ -1170,57 +1199,52 @@ var MapRef = class extends TypedRef {
       readonly: this.readonly
     };
   }
-  getOrCreateNode(key, shape) {
-    let node = this.propertyCache.get(key);
-    if (!node) {
+  getOrCreateRef(key, shape) {
+    let ref = this.propertyCache.get(key);
+    if (!ref) {
       if (isContainerShape(shape)) {
-        node = createContainerTypedRef(this.getTypedRefParams(key, shape));
-        this.propertyCache.set(key, node);
+        ref = createContainerTypedRef(this.getTypedRefParams(key, shape));
+        this.propertyCache.set(key, ref);
       } else {
         const containerValue = this.container.get(key);
         if (containerValue !== void 0) {
-          node = containerValue;
+          ref = containerValue;
         } else {
           const placeholder = this.placeholder?.[key];
           if (placeholder === void 0) {
             throw new Error("placeholder required");
           }
-          node = placeholder;
+          ref = placeholder;
         }
         if (!this.readonly) {
-          this.propertyCache.set(key, node);
+          this.propertyCache.set(key, ref);
         }
       }
-      if (node === void 0) throw new Error("no container made");
+      if (ref === void 0) throw new Error("no container made");
     }
     if (this.readonly && isContainerShape(shape)) {
       const existing = this.container.get(key);
       if (existing === void 0) {
         return this.placeholder?.[key];
       }
-      if (shape._type === "counter") {
-        return node.value;
-      }
-      if (shape._type === "text") {
-        return node.toString();
-      }
+      return unwrapReadonlyPrimitive(ref, shape);
     }
-    return node;
+    return ref;
   }
   createLazyProperties() {
     for (const key in this.shape.shapes) {
       const shape = this.shape.shapes[key];
       Object.defineProperty(this, key, {
-        get: () => this.getOrCreateNode(key, shape),
+        get: () => this.getOrCreateRef(key, shape),
         set: (value) => {
-          if (this.readonly) throw new Error("Cannot modify readonly ref");
+          this.assertMutable();
           if (isValueShape(shape)) {
             this.container.set(key, value);
             this.propertyCache.set(key, value);
           } else {
             if (value && typeof value === "object") {
-              const node = this.getOrCreateNode(key, shape);
-              if (assignPlainValueToTypedRef(node, value)) {
+              const ref = this.getOrCreateRef(key, shape);
+              if (assignPlainValueToTypedRef(ref, value)) {
                 return;
               }
             }
@@ -1234,31 +1258,26 @@ var MapRef = class extends TypedRef {
     }
   }
   toJSON() {
-    const result = {};
-    for (const key in this.shape.shapes) {
-      const value = this[key];
-      if (value && typeof value === "object" && "toJSON" in value) {
-        result[key] = value.toJSON();
-      } else {
-        result[key] = value;
-      }
+    if (this.readonly) {
+      const nativeJson = this.container.toJSON();
+      return mergeValue(this.shape, nativeJson, this.placeholder);
     }
-    return result;
+    return serializeRefToJSON(this, Object.keys(this.shape.shapes));
   }
-  // TOOD(duane): return correct type here
+  // TODO(duane): return correct type here
   get(key) {
     return this.container.get(key);
   }
   set(key, value) {
-    if (this.readonly) throw new Error("Cannot modify readonly ref");
+    this.assertMutable();
     this.container.set(key, value);
   }
   setContainer(key, container) {
-    if (this.readonly) throw new Error("Cannot modify readonly ref");
+    this.assertMutable();
     return this.container.setContainer(key, container);
   }
   delete(key) {
-    if (this.readonly) throw new Error("Cannot modify readonly ref");
+    this.assertMutable();
     this.container.delete(key);
   }
   has(key) {
@@ -1284,11 +1303,11 @@ var MovableListRef = class extends ListRefBase {
     this.container.set(index, value);
   }
   move(from, to) {
-    if (this.readonly) throw new Error("Cannot modify readonly ref");
+    this.assertMutable();
     this.container.move(from, to);
   }
   set(index, item) {
-    if (this.readonly) throw new Error("Cannot modify readonly ref");
+    this.assertMutable();
     return this.container.set(index, item);
   }
 };
@@ -1374,25 +1393,8 @@ var movableListProxyHandler = {
 };
 
 // src/typed-refs/record.ts
-import {
-  LoroCounter as LoroCounter3,
-  LoroList as LoroList3,
-  LoroMap as LoroMap3,
-  LoroMovableList as LoroMovableList3,
-  LoroText as LoroText3,
-  LoroTree as LoroTree2
-} from "loro-crdt";
-var containerConstructor2 = {
-  counter: LoroCounter3,
-  list: LoroList3,
-  map: LoroMap3,
-  movableList: LoroMovableList3,
-  record: LoroMap3,
-  text: LoroText3,
-  tree: LoroTree2
-};
 var RecordRef = class extends TypedRef {
-  nodeCache = /* @__PURE__ */ new Map();
+  refCache = /* @__PURE__ */ new Map();
   get shape() {
     return super.shape;
   }
@@ -1400,20 +1402,14 @@ var RecordRef = class extends TypedRef {
     return super.container;
   }
   absorbPlainValues() {
-    for (const [key, node] of this.nodeCache.entries()) {
-      if (node instanceof TypedRef) {
-        node.absorbPlainValues();
-        continue;
-      }
-      this.container.set(key, node);
-    }
+    absorbCachedPlainValues(this.refCache, () => this.container);
   }
   getTypedRefParams(key, shape) {
     let placeholder = this.placeholder?.[key];
     if (placeholder === void 0) {
       placeholder = deriveShapePlaceholder(shape);
     }
-    const LoroContainer = containerConstructor2[shape._type];
+    const LoroContainer = containerConstructor[shape._type];
     return {
       shape,
       placeholder,
@@ -1421,61 +1417,58 @@ var RecordRef = class extends TypedRef {
       readonly: this.readonly
     };
   }
-  getOrCreateNode(key) {
+  getOrCreateRef(key) {
     if (this.readonly && isContainerShape(this.shape.shape)) {
       const existing = this.container.get(key);
       if (existing === void 0) {
         return void 0;
       }
     }
-    let node = this.nodeCache.get(key);
-    if (!node) {
+    let ref = this.refCache.get(key);
+    if (!ref) {
       const shape = this.shape.shape;
       if (isContainerShape(shape)) {
-        node = createContainerTypedRef(
+        ref = createContainerTypedRef(
           this.getTypedRefParams(key, shape)
         );
-        this.nodeCache.set(key, node);
+        this.refCache.set(key, ref);
       } else {
         const containerValue = this.container.get(key);
         if (containerValue !== void 0) {
-          node = containerValue;
+          ref = containerValue;
         } else {
           const placeholder = this.placeholder?.[key];
           if (placeholder === void 0) {
-            node = shape._plain;
+            ref = shape._plain;
           } else {
-            node = placeholder;
+            ref = placeholder;
           }
         }
-        if (node !== void 0 && !this.readonly) {
-          this.nodeCache.set(key, node);
+        if (ref !== void 0 && !this.readonly) {
+          this.refCache.set(key, ref);
         }
       }
     }
     if (this.readonly && isContainerShape(this.shape.shape)) {
-      const shape = this.shape.shape;
-      if (shape._type === "counter") {
-        return node.value;
-      }
-      if (shape._type === "text") {
-        return node.toString();
-      }
+      return unwrapReadonlyPrimitive(
+        ref,
+        this.shape.shape
+      );
     }
-    return node;
+    return ref;
   }
   get(key) {
-    return this.getOrCreateNode(key);
+    return this.getOrCreateRef(key);
   }
   set(key, value) {
-    if (this.readonly) throw new Error("Cannot modify readonly ref");
+    this.assertMutable();
     if (isValueShape(this.shape.shape)) {
       this.container.set(key, value);
-      this.nodeCache.set(key, value);
+      this.refCache.set(key, value);
     } else {
       if (value && typeof value === "object") {
-        const node = this.getOrCreateNode(key);
-        if (assignPlainValueToTypedRef(node, value)) {
+        const ref = this.getOrCreateRef(key);
+        if (assignPlainValueToTypedRef(ref, value)) {
           return;
         }
       }
@@ -1485,13 +1478,13 @@ var RecordRef = class extends TypedRef {
     }
   }
   setContainer(key, container) {
-    if (this.readonly) throw new Error("Cannot modify readonly ref");
+    this.assertMutable();
     return this.container.setContainer(key, container);
   }
   delete(key) {
-    if (this.readonly) throw new Error("Cannot modify readonly ref");
+    this.assertMutable();
     this.container.delete(key);
-    this.nodeCache.delete(key);
+    this.refCache.delete(key);
   }
   has(key) {
     return this.container.get(key) !== void 0;
@@ -1506,16 +1499,20 @@ var RecordRef = class extends TypedRef {
     return this.container.size;
   }
   toJSON() {
-    const result = {};
-    for (const key of this.keys()) {
-      const value = this.get(key);
-      if (value && typeof value === "object" && "toJSON" in value) {
-        result[key] = value.toJSON();
-      } else {
-        result[key] = value;
+    if (this.readonly) {
+      const nativeJson = this.container.toJSON();
+      const result = {};
+      for (const key of Object.keys(nativeJson)) {
+        const nestedPlaceholderValue = deriveShapePlaceholder(this.shape.shape);
+        result[key] = mergeValue(
+          this.shape.shape,
+          nativeJson[key],
+          nestedPlaceholderValue
+        );
       }
+      return result;
     }
-    return result;
+    return serializeRefToJSON(this, this.keys());
   }
 };
 
@@ -1525,11 +1522,11 @@ var TextRef = class extends TypedRef {
   }
   // Text methods
   insert(index, content) {
-    if (this.readonly) throw new Error("Cannot modify readonly ref");
+    this.assertMutable();
     this.container.insert(index, content);
   }
   delete(index, len) {
-    if (this.readonly) throw new Error("Cannot modify readonly ref");
+    this.assertMutable();
     this.container.delete(index, len);
   }
   toString() {
@@ -1539,22 +1536,22 @@ var TextRef = class extends TypedRef {
     return this.toString();
   }
   update(text) {
-    if (this.readonly) throw new Error("Cannot modify readonly ref");
+    this.assertMutable();
     this.container.update(text);
   }
   mark(range, key, value) {
-    if (this.readonly) throw new Error("Cannot modify readonly ref");
+    this.assertMutable();
     this.container.mark(range, key, value);
   }
   unmark(range, key) {
-    if (this.readonly) throw new Error("Cannot modify readonly ref");
+    this.assertMutable();
     this.container.unmark(range, key);
   }
   toDelta() {
     return this.container.toDelta();
   }
   applyDelta(delta) {
-    if (this.readonly) throw new Error("Cannot modify readonly ref");
+    this.assertMutable();
     this.container.applyDelta(delta);
   }
   get length() {
@@ -1567,15 +1564,15 @@ var TreeRef = class extends TypedRef {
   absorbPlainValues() {
   }
   createNode(parent, index) {
-    if (this.readonly) throw new Error("Cannot modify readonly ref");
+    this.assertMutable();
     return this.container.createNode(parent, index);
   }
   move(target, parent, index) {
-    if (this.readonly) throw new Error("Cannot modify readonly ref");
+    this.assertMutable();
     this.container.move(target, parent, index);
   }
   delete(target) {
-    if (this.readonly) throw new Error("Cannot modify readonly ref");
+    this.assertMutable();
     this.container.delete(target);
   }
   has(target) {
@@ -1587,6 +1584,48 @@ var TreeRef = class extends TypedRef {
 };
 
 // src/typed-refs/utils.ts
+var containerConstructor = {
+  counter: LoroCounter2,
+  list: LoroList2,
+  map: LoroMap2,
+  movableList: LoroMovableList2,
+  record: LoroMap2,
+  // Records use LoroMap as their underlying container
+  text: LoroText2,
+  tree: LoroTree
+};
+function unwrapReadonlyPrimitive(ref, shape) {
+  if (shape._type === "counter") {
+    return ref.value;
+  }
+  if (shape._type === "text") {
+    return ref.toString();
+  }
+  return ref;
+}
+function absorbCachedPlainValues(cache, getContainer) {
+  let container;
+  for (const [key, ref] of cache.entries()) {
+    if (ref instanceof TypedRef) {
+      ref.absorbPlainValues();
+    } else {
+      if (!container) container = getContainer();
+      container.set(key, ref);
+    }
+  }
+}
+function serializeRefToJSON(ref, keys) {
+  const result = {};
+  for (const key of keys) {
+    const value = ref[key];
+    if (value && typeof value === "object" && "toJSON" in value) {
+      result[key] = value.toJSON();
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
 function createContainerTypedRef(params) {
   switch (params.shape._type) {
     case "counter":
@@ -1618,23 +1657,23 @@ function createContainerTypedRef(params) {
       );
   }
 }
-function assignPlainValueToTypedRef(node, value) {
-  const shapeType = node.shape._type;
+function assignPlainValueToTypedRef(ref, value) {
+  const shapeType = ref.shape._type;
   if (shapeType === "map" || shapeType === "record") {
     for (const k in value) {
       ;
-      node[k] = value[k];
+      ref[k] = value[k];
     }
     return true;
   }
   if (shapeType === "list" || shapeType === "movableList") {
     if (Array.isArray(value)) {
-      const listNode = node;
-      if (listNode.length > 0) {
-        listNode.delete(0, listNode.length);
+      const listRef = ref;
+      if (listRef.length > 0) {
+        listRef.delete(0, listRef.length);
       }
       for (const item of value) {
-        listNode.push(item);
+        listRef.push(item);
       }
       return true;
     }
@@ -1684,20 +1723,15 @@ var DocRef = class extends TypedRef {
         return this.requiredPlaceholder[key];
       }
     }
-    let node = this.propertyCache.get(key);
-    if (!node) {
-      node = createContainerTypedRef(this.getTypedRefParams(key, shape));
-      this.propertyCache.set(key, node);
+    let ref = this.propertyCache.get(key);
+    if (!ref) {
+      ref = createContainerTypedRef(this.getTypedRefParams(key, shape));
+      this.propertyCache.set(key, ref);
     }
     if (this.readonly) {
-      if (shape._type === "counter") {
-        return node.value;
-      }
-      if (shape._type === "text") {
-        return node.toString();
-      }
+      return unwrapReadonlyPrimitive(ref, shape);
     }
-    return node;
+    return ref;
   }
   createLazyProperties() {
     for (const key in this.shape.shapes) {
@@ -1709,20 +1743,14 @@ var DocRef = class extends TypedRef {
     }
   }
   toJSON() {
-    const result = {};
-    for (const key in this.shape.shapes) {
-      const value = this[key];
-      if (value && typeof value === "object" && "toJSON" in value) {
-        result[key] = value.toJSON();
-      } else {
-        result[key] = value;
-      }
-    }
-    return result;
+    return serializeRefToJSON(
+      this,
+      Object.keys(this.shape.shapes)
+    );
   }
   absorbPlainValues() {
-    for (const [, node] of this.propertyCache.entries()) {
-      node.absorbPlainValues();
+    for (const [, ref] of this.propertyCache.entries()) {
+      ref.absorbPlainValues();
     }
   }
 };