@loro-extended/change 0.6.0 → 0.8.0

package/src/draft-nodes/record.ts

@@ -13,10 +13,13 @@ import type {
   ContainerShape,
   RecordContainerShape,
 } from "../shape.js"
-import type { InferDraftType } from "../types.js"
+import type { Infer, InferDraftType } from "../types.js"
 import { isContainerShape, isValueShape } from "../utils/type-guards.js"
 import { DraftNode, type DraftNodeParams } from "./base.js"
-import { createContainerDraftNode } from "./utils.js"
+import {
+  assignPlainValueToDraftNode,
+  createContainerDraftNode,
+} from "./utils.js"
 
 const containerConstructor = {
   counter: LoroCounter,
@@ -32,54 +35,9 @@ const containerConstructor = {
 export class RecordDraftNode<
   NestedShape extends ContainerOrValueShape,
 > extends DraftNode<any> {
+  [key: string]: Infer<NestedShape> | any
   private nodeCache = new Map<string, DraftNode<ContainerShape> | Value>()
 
-  constructor(params: DraftNodeParams<RecordContainerShape<NestedShape>>) {
-    super(params)
-    // We don't need to create lazy properties because keys are dynamic
-    // But we could use a Proxy if we wanted property access syntax like record.key
-    // However, for now let's stick to get/set methods or maybe Proxy for better DX?
-    // The requirement says "records with uniform specific key type and value".
-    // Usually records are accessed via keys.
-    // If we want `draft.record.key`, we need a Proxy.
-    // biome-ignore lint/correctness/noConstructorReturn: Proxy return is intentional
-    return new Proxy(this, {
-      get: (target, prop) => {
-        if (typeof prop === "string" && !(prop in target)) {
-          return target.get(prop)
-        }
-        return Reflect.get(target, prop)
-      },
-      set: (target, prop, value) => {
-        if (typeof prop === "string" && !(prop in target)) {
-          target.set(prop, value)
-          return true
-        }
-        return Reflect.set(target, prop, value)
-      },
-      deleteProperty: (target, prop) => {
-        if (typeof prop === "string" && !(prop in target)) {
-          target.delete(prop)
-          return true
-        }
-        return Reflect.deleteProperty(target, prop)
-      },
-      ownKeys: target => {
-        return target.keys()
-      },
-      getOwnPropertyDescriptor: (target, prop) => {
-        if (typeof prop === "string" && target.has(prop)) {
-          return {
-            configurable: true,
-            enumerable: true,
-            value: target.get(prop),
-          }
-        }
-        return Reflect.getOwnPropertyDescriptor(target, prop)
-      },
-    })
-  }
-
   protected get shape(): RecordContainerShape<NestedShape> {
     return super.shape as RecordContainerShape<NestedShape>
   }
@@ -105,19 +63,20 @@ export class RecordDraftNode<
     key: string,
     shape: S,
   ): DraftNodeParams<ContainerShape> {
-    const emptyState = (this.emptyState as any)?.[key]
+    const placeholder = (this.placeholder as any)?.[key]
 
     const LoroContainer = containerConstructor[shape._type]
 
     return {
       shape,
-      emptyState,
+      placeholder,
       getContainer: () =>
         this.container.getOrCreateContainer(key, new (LoroContainer as any)()),
+      readonly: this.readonly,
     }
   }
 
-  getOrCreateNode(key: string): InferDraftType<NestedShape> {
+  getOrCreateNode(key: string): any {
     let node = this.nodeCache.get(key)
     if (!node) {
       const shape = this.shape.shape
@@ -125,36 +84,38 @@ export class RecordDraftNode<
         node = createContainerDraftNode(
           this.getDraftNodeParams(key, shape as ContainerShape),
         )
+        // Cache container nodes
+        this.nodeCache.set(key, node)
       } else {
         // For value shapes, first try to get the value from the container
         const containerValue = this.container.get(key)
         if (containerValue !== undefined) {
           node = containerValue as Value
         } else {
-          // Only fall back to empty state if the container doesn't have the value
-          const emptyState = (this.emptyState as any)?.[key]
-          // For records, empty state might not have the key, which is fine?
-          // But if we are accessing it, maybe we expect it to exist or be created?
-          // If it's a value type, we can't really "create" it without a value.
-          // So if it's undefined in container and empty state, we return undefined?
-          // But the return type expects Value.
-          // Let's check MapDraftNode.
-          // MapDraftNode throws "empty state required" if not found.
-          // But for Record, keys are dynamic.
-          if (emptyState === undefined) {
-            // If it's a value type and not in container or empty state,
-            // we should probably return undefined if the type allows it,
-            // or maybe the default value for that type?
-            // But we don't have a default value generator for shapes.
-            // Actually Shape.plain.* factories have _plain and _draft which are defaults.
+          // Only fall back to placeholder if the container doesn't have the value
+          const placeholder = (this.placeholder as any)?.[key]
+          if (placeholder === undefined) {
+            // If it's a value type and not in container or placeholder,
+            // fallback to the default value from the shape
             node = (shape as any)._plain
           } else {
-            node = emptyState as Value
+            node = placeholder as Value
           }
         }
+        // Only cache primitive values if NOT readonly
+        if (node !== undefined && !this.readonly) {
+          this.nodeCache.set(key, node)
+        }
       }
-      if (node !== undefined) {
-        this.nodeCache.set(key, node)
+    }
+
+    if (this.readonly && isContainerShape(this.shape.shape)) {
+      const shape = this.shape.shape as ContainerShape
+      if (shape._type === "counter") {
+        return (node as any).value
+      }
+      if (shape._type === "text") {
+        return (node as any).toString()
       }
     }
 
@@ -166,22 +127,21 @@ export class RecordDraftNode<
   }
 
   set(key: string, value: any): void {
+    if (this.readonly) throw new Error("Cannot modify readonly doc")
     if (isValueShape(this.shape.shape)) {
       this.container.set(key, value)
-      // Update cache if needed?
-      // MapDraftNode updates container directly for values.
-      // But we also cache values in nodeCache for consistency?
-      // MapDraftNode doesn't cache values in propertyCache if they are set via setter?
-      // Actually MapDraftNode setter:
-      // set: isValueShape(shape) ? value => this.container.set(key, value) : undefined
-      // It doesn't update propertyCache.
-      // But getOrCreateNode checks propertyCache first.
-      // So if we set it, we should probably update propertyCache or clear it for that key.
       this.nodeCache.set(key, value)
     } else {
       // For containers, we can't set them directly usually.
       // But if the user passes a plain object that matches the shape, maybe we should convert it?
-      // But typically we modify the draft node.
+      if (value && typeof value === "object") {
+        const node = this.getOrCreateNode(key)
+
+        if (assignPlainValueToDraftNode(node, value)) {
+          return
+        }
+      }
+
       throw new Error(
         "Cannot set container directly, modify the draft node instead",
       )
@@ -189,10 +149,12 @@ export class RecordDraftNode<
   }
 
   setContainer<C extends Container>(key: string, container: C): C {
+    if (this.readonly) throw new Error("Cannot modify readonly doc")
     return this.container.setContainer(key, container)
   }
 
   delete(key: string): void {
+    if (this.readonly) throw new Error("Cannot modify readonly doc")
     this.container.delete(key)
     this.nodeCache.delete(key)
   }

package/src/draft-nodes/utils.ts

@@ -13,6 +13,11 @@ import { CounterDraftNode } from "./counter.js"
 import { ListDraftNode } from "./list.js"
 import { MapDraftNode } from "./map.js"
 import { MovableListDraftNode } from "./movable-list.js"
+import {
+  listProxyHandler,
+  movableListProxyHandler,
+  recordProxyHandler,
+} from "./proxy-handlers.js"
 import { RecordDraftNode } from "./record.js"
 import { TextDraftNode } from "./text.js"
 import { TreeDraftNode } from "./tree.js"
@@ -32,16 +37,23 @@ export function createContainerDraftNode(
         params as DraftNodeParams<CounterContainerShape>,
       )
     case "list":
-      return new ListDraftNode(params as DraftNodeParams<ListContainerShape>)
+      return new Proxy(
+        new ListDraftNode(params as DraftNodeParams<ListContainerShape>),
+        listProxyHandler,
+      )
     case "map":
       return new MapDraftNode(params as DraftNodeParams<MapContainerShape>)
     case "movableList":
-      return new MovableListDraftNode(
-        params as DraftNodeParams<MovableListContainerShape>,
+      return new Proxy(
+        new MovableListDraftNode(
+          params as DraftNodeParams<MovableListContainerShape>,
+        ),
+        movableListProxyHandler,
       )
     case "record":
-      return new RecordDraftNode(
-        params as DraftNodeParams<RecordContainerShape>,
+      return new Proxy(
+        new RecordDraftNode(params as DraftNodeParams<RecordContainerShape>),
+        recordProxyHandler,
       )
     case "text":
       return new TextDraftNode(params as DraftNodeParams<TextContainerShape>)
@@ -53,3 +65,32 @@ export function createContainerDraftNode(
       )
   }
 }
+
+export function assignPlainValueToDraftNode(
+  node: DraftNode<any>,
+  value: any,
+): boolean {
+  const shapeType = (node as any).shape._type
+
+  if (shapeType === "map" || shapeType === "record") {
+    for (const k in value) {
+      ;(node 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)
+      }
+      for (const item of value) {
+        listNode.push(item)
+      }
+      return true
+    }
+  }
+
+  return false
+}

package/src/equality.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from "vitest"
+import { Shape } from "./shape.js"
+import { createTypedDoc } from "./typed-doc.js"
+
+describe("Equality Check", () => {
+  const schema = Shape.doc({
+    counter: Shape.counter().placeholder(1),
+  })
+
+  it("should compare equal to plain object", () => {
+    const doc = createTypedDoc(schema)
+    expect(doc.value.counter).toEqual(1)
+  })
+
+  it("should compare equal using toJSON", () => {
+    const doc = createTypedDoc(schema)
+    expect(doc.toJSON()).toEqual({ counter: 1 })
+  })
+})

package/src/index.ts

@@ -1,6 +1,10 @@
 // Main API exports
-export { createTypedDoc, TypedDoc } from "./change.js"
-export { mergeValue, overlayEmptyState } from "./overlay.js"
+
+export {
+  derivePlaceholder,
+  deriveShapePlaceholder,
+} from "./derive-placeholder.js"
+export { mergeValue, overlayPlaceholder } from "./overlay.js"
 export type {
   ArrayValueShape,
   ContainerOrValueShape,
@@ -23,16 +27,19 @@ export type {
   UnionValueShape,
   // Value shapes
   ValueShape,
-  // ...
+  // WithPlaceholder type for shapes that support .placeholder()
+  WithPlaceholder,
 } from "./shape.js"
 // Schema and type exports
 export { Shape } from "./shape.js"
+export { createTypedDoc, TypedDoc } from "./typed-doc.js"
 export type {
+  DeepReadonly,
   Draft,
+  // Type inference - Infer<T> is the recommended unified helper
+  Infer,
   InferDraftType,
-  // Type inference
-  InferEmptyStateType,
-  InferPlainType,
+  InferPlaceholderType,
 } from "./types.js"
 // Utility exports
-export { validateEmptyState } from "./validation.js"
+export { validatePlaceholder } from "./validation.js"