@loro-extended/change 0.9.0 → 0.9.1

package/src/typed-refs/utils.ts

@@ -1,3 +1,12 @@
+import {
+  LoroCounter,
+  LoroList,
+  LoroMap,
+  LoroMovableList,
+  LoroText,
+  LoroTree,
+  type Value,
+} from "loro-crdt"
 import type {
   ContainerShape,
   CounterContainerShape,
@@ -8,7 +17,7 @@ import type {
   TextContainerShape,
   TreeContainerShape,
 } from "../shape.js"
-import type { TypedRef, TypedRefParams } from "./base.js"
+import { TypedRef, type TypedRefParams } from "./base.js"
 import { CounterRef } from "./counter.js"
 import { ListRef } from "./list.js"
 import { MapRef } from "./map.js"
@@ -22,6 +31,82 @@ import { RecordRef } from "./record.js"
 import { TextRef } from "./text.js"
 import { TreeRef } from "./tree.js"
 
+/**
+ * Mapping from container shape types to their Loro constructor classes.
+ * Used when creating new containers via getOrCreateContainer().
+ */
+export const containerConstructor = {
+  counter: LoroCounter,
+  list: LoroList,
+  map: LoroMap,
+  movableList: LoroMovableList,
+  record: LoroMap, // Records use LoroMap as their underlying container
+  text: LoroText,
+  tree: LoroTree,
+} as const
+
+/**
+ * Unwraps a TypedRef to its primitive value for readonly access.
+ * Counter refs return their numeric value, Text refs return their string.
+ * Other container types are returned as-is.
+ */
+export function unwrapReadonlyPrimitive(
+  ref: TypedRef<any>,
+  shape: ContainerShape,
+): any {
+  if (shape._type === "counter") {
+    return (ref as any).value
+  }
+  if (shape._type === "text") {
+    return (ref as any).toString()
+  }
+  return ref
+}
+
+/**
+ * Absorbs cached plain values back into a LoroMap container.
+ * For TypedRef entries, recursively calls absorbPlainValues().
+ * For plain Value entries, sets them directly on the container.
+ */
+export function absorbCachedPlainValues(
+  cache: Map<string, TypedRef<ContainerShape> | Value>,
+  getContainer: () => LoroMap,
+): void {
+  let container: LoroMap | undefined
+
+  for (const [key, ref] of cache.entries()) {
+    if (ref instanceof TypedRef) {
+      // Contains a TypedRef, not a plain Value: keep recursing
+      ref.absorbPlainValues()
+    } else {
+      // Plain value!
+      if (!container) container = getContainer()
+      container.set(key, ref)
+    }
+  }
+}
+
+/**
+ * Serializes a TypedRef to JSON by iterating over its keys.
+ * For nested TypedRefs with toJSON(), calls their toJSON method.
+ * For plain values, includes them directly.
+ */
+export function serializeRefToJSON(
+  ref: Record<string, any>,
+  keys: Iterable<string>,
+): Record<string, any> {
+  const result: Record<string, any> = {}
+  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
+}
+
 // Generic catch-all overload
 export function createContainerTypedRef<T extends ContainerShape>(
   params: TypedRefParams<T>,
@@ -63,26 +148,26 @@ export function createContainerTypedRef(
 }
 
 export function assignPlainValueToTypedRef(
-  node: TypedRef<any>,
+  ref: TypedRef<any>,
   value: any,
 ): boolean {
-  const shapeType = (node as any).shape._type
+  const shapeType = (ref as any).shape._type
 
   if (shapeType === "map" || shapeType === "record") {
     for (const k in value) {
-      ;(node as any)[k] = value[k]
+      ;(ref as any)[k] = value[k]
     }
     return true
   }
 
   if (shapeType === "list" || shapeType === "movableList") {
     if (Array.isArray(value)) {
-      const listNode = node as any
-      if (listNode.length > 0) {
-        listNode.delete(0, listNode.length)
+      const listRef = ref as any
+      if (listRef.length > 0) {
+        listRef.delete(0, listRef.length)
       }
       for (const item of value) {
-        listNode.push(item)
+        listRef.push(item)
       }
       return true
     }