@loro-extended/change 0.2.0

package/src/draft-nodes/map.ts

@@ -0,0 +1,156 @@
+import {
+  type Container,
+  LoroCounter,
+  LoroList,
+  LoroMap,
+  LoroMovableList,
+  LoroText,
+  LoroTree,
+  type Value,
+} from "loro-crdt"
+import type {
+  ContainerOrValueShape,
+  ContainerShape,
+  MapContainerShape,
+  ValueShape,
+} from "../shape.js"
+import { isContainerShape, isValueShape } from "../utils/type-guards.js"
+import { DraftNode, type DraftNodeParams } from "./base.js"
+import { createContainerDraftNode } from "./utils.js"
+
+const containerConstructor = {
+  counter: LoroCounter,
+  list: LoroList,
+  map: LoroMap,
+  movableList: LoroMovableList,
+  record: LoroMap,
+  text: LoroText,
+  tree: LoroTree,
+} as const
+
+// Map draft node
+export class MapDraftNode<
+  NestedShapes extends Record<string, ContainerOrValueShape>,
+> extends DraftNode<any> {
+  private propertyCache = new Map<string, DraftNode<ContainerShape> | Value>()
+
+  constructor(params: DraftNodeParams<MapContainerShape<NestedShapes>>) {
+    super(params)
+    this.createLazyProperties()
+  }
+
+  protected get shape(): MapContainerShape<NestedShapes> {
+    return super.shape as MapContainerShape<NestedShapes>
+  }
+
+  protected get container(): LoroMap {
+    return super.container as LoroMap
+  }
+
+  absorbPlainValues() {
+    for (const [key, node] of this.propertyCache.entries()) {
+      if (node instanceof DraftNode) {
+        // Contains a DraftNode, not a plain Value: keep recursing
+        node.absorbPlainValues()
+        continue
+      }
+
+      // Plain value!
+      this.container.set(key, node)
+    }
+  }
+
+  getDraftNodeParams<S extends ContainerShape>(
+    key: string,
+    shape: S,
+  ): DraftNodeParams<ContainerShape> {
+    const emptyState = (this.emptyState as any)?.[key]
+
+    const LoroContainer = containerConstructor[shape._type]
+
+    return {
+      shape,
+      emptyState,
+      getContainer: () =>
+        this.container.getOrCreateContainer(key, new (LoroContainer as any)()),
+    }
+  }
+
+  getOrCreateNode<Shape extends ContainerShape | ValueShape>(
+    key: string,
+    shape: Shape,
+  ): Shape extends ContainerShape ? DraftNode<Shape> : Value {
+    let node = this.propertyCache.get(key)
+    if (!node) {
+      if (isContainerShape(shape)) {
+        node = createContainerDraftNode(this.getDraftNodeParams(key, shape))
+      } 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]
+          if (!emptyState) {
+            throw new Error("empty state required")
+          }
+          node = emptyState as Value
+        }
+      }
+      if (!node) throw new Error("no container made")
+      this.propertyCache.set(key, node)
+    }
+
+    return node as Shape extends ContainerShape ? DraftNode<Shape> : Value
+  }
+
+  private createLazyProperties(): void {
+    for (const key in this.shape.shapes) {
+      const shape = this.shape.shapes[key]
+      Object.defineProperty(this, key, {
+        get: () => this.getOrCreateNode(key, shape),
+        set: isValueShape(shape)
+          ? value => {
+              // console.log("set value", value)
+              this.container.set(key, value)
+            }
+          : undefined,
+      })
+    }
+  }
+
+  // TOOD(duane): return correct type here
+  get(key: string): any {
+    return this.container.get(key)
+  }
+
+  set(key: string, value: Value): void {
+    this.container.set(key, value)
+  }
+
+  setContainer<C extends Container>(key: string, container: C): C {
+    return this.container.setContainer(key, container)
+  }
+
+  delete(key: string): void {
+    this.container.delete(key)
+  }
+
+  has(key: string): boolean {
+    // LoroMap doesn't have a has method, so we check if get returns undefined
+    return this.container.get(key) !== undefined
+  }
+
+  keys(): string[] {
+    return this.container.keys()
+  }
+
+  values(): any[] {
+    return this.container.values()
+  }
+
+  get size(): number {
+    return this.container.size
+  }
+}

package/src/draft-nodes/movable-list.ts

@@ -0,0 +1,26 @@
+import type { Container, LoroMovableList } from "loro-crdt"
+import type { ContainerOrValueShape } from "../shape.js"
+import { ListDraftNodeBase } from "./list-base.js"
+
+// Movable list draft node
+export class MovableListDraftNode<
+  NestedShape extends ContainerOrValueShape,
+  Item = NestedShape["_plain"],
+> extends ListDraftNodeBase<NestedShape> {
+  protected get container(): LoroMovableList {
+    return super.container as LoroMovableList
+  }
+
+  protected absorbValueAtIndex(index: number, value: any): void {
+    // LoroMovableList has set method
+    this.container.set(index, value)
+  }
+
+  move(from: number, to: number): void {
+    this.container.move(from, to)
+  }
+
+  set(index: number, item: Exclude<Item, Container>) {
+    return this.container.set(index, item)
+  }
+}

package/src/draft-nodes/record.ts

@@ -0,0 +1,215 @@
+import {
+  type Container,
+  LoroCounter,
+  LoroList,
+  LoroMap,
+  LoroMovableList,
+  LoroText,
+  LoroTree,
+  type Value,
+} from "loro-crdt"
+import type {
+  ContainerOrValueShape,
+  ContainerShape,
+  RecordContainerShape,
+} from "../shape.js"
+import type { InferDraftType } from "../types.js"
+import { isContainerShape, isValueShape } from "../utils/type-guards.js"
+import { DraftNode, type DraftNodeParams } from "./base.js"
+import { createContainerDraftNode } from "./utils.js"
+
+const containerConstructor = {
+  counter: LoroCounter,
+  list: LoroList,
+  map: LoroMap,
+  movableList: LoroMovableList,
+  record: LoroMap,
+  text: LoroText,
+  tree: LoroTree,
+} as const
+
+// Record draft node
+export class RecordDraftNode<
+  NestedShape extends ContainerOrValueShape,
+> extends DraftNode<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>
+  }
+
+  protected get container(): LoroMap {
+    return super.container as LoroMap
+  }
+
+  absorbPlainValues() {
+    for (const [key, node] of this.nodeCache.entries()) {
+      if (node instanceof DraftNode) {
+        // Contains a DraftNode, not a plain Value: keep recursing
+        node.absorbPlainValues()
+        continue
+      }
+
+      // Plain value!
+      this.container.set(key, node)
+    }
+  }
+
+  getDraftNodeParams<S extends ContainerShape>(
+    key: string,
+    shape: S,
+  ): DraftNodeParams<ContainerShape> {
+    const emptyState = (this.emptyState as any)?.[key]
+
+    const LoroContainer = containerConstructor[shape._type]
+
+    return {
+      shape,
+      emptyState,
+      getContainer: () =>
+        this.container.getOrCreateContainer(key, new (LoroContainer as any)()),
+    }
+  }
+
+  getOrCreateNode(key: string): InferDraftType<NestedShape> {
+    let node = this.nodeCache.get(key)
+    if (!node) {
+      const shape = this.shape.shape
+      if (isContainerShape(shape)) {
+        node = createContainerDraftNode(
+          this.getDraftNodeParams(key, shape as ContainerShape),
+        )
+      } 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.
+            node = (shape as any)._plain
+          } else {
+            node = emptyState as Value
+          }
+        }
+      }
+      if (node !== undefined) {
+        this.nodeCache.set(key, node)
+      }
+    }
+
+    return node as any
+  }
+
+  get(key: string): InferDraftType<NestedShape> {
+    return this.getOrCreateNode(key)
+  }
+
+  set(key: string, value: any): void {
+    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.
+      throw new Error(
+        "Cannot set container directly, modify the draft node instead",
+      )
+    }
+  }
+
+  setContainer<C extends Container>(key: string, container: C): C {
+    return this.container.setContainer(key, container)
+  }
+
+  delete(key: string): void {
+    this.container.delete(key)
+    this.nodeCache.delete(key)
+  }
+
+  has(key: string): boolean {
+    return this.container.get(key) !== undefined
+  }
+
+  keys(): string[] {
+    return this.container.keys()
+  }
+
+  values(): any[] {
+    return this.container.values()
+  }
+
+  get size(): number {
+    return this.container.size
+  }
+}

package/src/draft-nodes/text.ts

@@ -0,0 +1,48 @@
+import type { TextContainerShape } from "../shape.js"
+import { DraftNode } from "./base.js"
+
+// Text draft node
+export class TextDraftNode extends DraftNode<TextContainerShape> {
+  absorbPlainValues() {
+    // no plain values contained within
+  }
+
+  // Text methods
+  insert(index: number, content: string): void {
+    // TODO(duane): condition can be removed when https://github.com/loro-dev/loro/issues/872 is addressed
+    if (content.length === 0) return
+    this.container.insert(index, content)
+  }
+
+  delete(index: number, len: number): void {
+    this.container.delete(index, len)
+  }
+
+  toString(): string {
+    return this.container.toString()
+  }
+
+  update(text: string): void {
+    this.container.update(text)
+  }
+
+  mark(range: { start: number; end: number }, key: string, value: any): void {
+    this.container.mark(range, key, value)
+  }
+
+  unmark(range: { start: number; end: number }, key: string): void {
+    this.container.unmark(range, key)
+  }
+
+  toDelta(): any[] {
+    return this.container.toDelta()
+  }
+
+  applyDelta(delta: any[]): void {
+    this.container.applyDelta(delta)
+  }
+
+  get length(): number {
+    return this.container.length
+  }
+}

package/src/draft-nodes/tree.ts

@@ -0,0 +1,31 @@
+import type { TreeContainerShape } from "../shape.js"
+import { DraftNode } from "./base.js"
+
+// Tree draft node
+export class TreeDraftNode<T extends TreeContainerShape> extends DraftNode<T> {
+  absorbPlainValues() {
+    // TODO(duane): implement for trees
+  }
+
+  createNode(parent?: any, index?: number): any {
+    return this.container.createNode(parent, index)
+  }
+
+  move(target: any, parent?: any, index?: number): void {
+    this.container.move(target, parent, index)
+  }
+
+  delete(target: any): void {
+    this.container.delete(target)
+  }
+
+  has(target: any): boolean {
+    return this.container.has(target)
+  }
+
+  getNodeByID(id: any): any {
+    return this.container.getNodeByID
+      ? this.container.getNodeByID(id)
+      : undefined
+  }
+}

package/src/draft-nodes/utils.ts

@@ -0,0 +1,55 @@
+import type {
+  ContainerShape,
+  CounterContainerShape,
+  ListContainerShape,
+  MapContainerShape,
+  MovableListContainerShape,
+  RecordContainerShape,
+  TextContainerShape,
+  TreeContainerShape,
+} from "../shape.js"
+import type { DraftNode, DraftNodeParams } from "./base.js"
+import { CounterDraftNode } from "./counter.js"
+import { ListDraftNode } from "./list.js"
+import { MapDraftNode } from "./map.js"
+import { MovableListDraftNode } from "./movable-list.js"
+import { RecordDraftNode } from "./record.js"
+import { TextDraftNode } from "./text.js"
+import { TreeDraftNode } from "./tree.js"
+
+// Generic catch-all overload
+export function createContainerDraftNode<T extends ContainerShape>(
+  params: DraftNodeParams<T>,
+): DraftNode<T>
+
+// Implementation
+export function createContainerDraftNode(
+  params: DraftNodeParams<ContainerShape>,
+): DraftNode<ContainerShape> {
+  switch (params.shape._type) {
+    case "counter":
+      return new CounterDraftNode(
+        params as DraftNodeParams<CounterContainerShape>,
+      )
+    case "list":
+      return new ListDraftNode(params as DraftNodeParams<ListContainerShape>)
+    case "map":
+      return new MapDraftNode(params as DraftNodeParams<MapContainerShape>)
+    case "movableList":
+      return new MovableListDraftNode(
+        params as DraftNodeParams<MovableListContainerShape>,
+      )
+    case "record":
+      return new RecordDraftNode(
+        params as DraftNodeParams<RecordContainerShape>,
+      )
+    case "text":
+      return new TextDraftNode(params as DraftNodeParams<TextContainerShape>)
+    case "tree":
+      return new TreeDraftNode(params as DraftNodeParams<TreeContainerShape>)
+    default:
+      throw new Error(
+        `Unknown container type: ${(params.shape as ContainerShape)._type}`,
+      )
+  }
+}

package/src/index.ts

@@ -0,0 +1,33 @@
+// Main API exports
+export { createTypedDoc, TypedDoc } from "./change.js"
+export { mergeValue, overlayEmptyState } from "./overlay.js"
+export type {
+  ArrayValueShape,
+  ContainerOrValueShape,
+  ContainerShape,
+  ContainerType as RootContainerType,
+  // Container shapes
+  CounterContainerShape,
+  // Schema node types
+  DocShape,
+  ListContainerShape,
+  MapContainerShape,
+  MovableListContainerShape,
+  RecordContainerShape,
+  RecordValueShape,
+  TextContainerShape,
+  TreeContainerShape,
+  // Value shapes
+  ValueShape,
+  // ...
+} from "./shape.js"
+// Schema and type exports
+export { Shape } from "./shape.js"
+export type {
+  Draft,
+  InferDraftType,
+  // Type inference
+  InferPlainType,
+} from "./types.js"
+// Utility exports
+export { validateEmptyState } from "./validation.js"