reptree 0.1.4 → 0.2.0

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+import * as Y from 'yjs';
+
 declare class OpId {
     readonly counter: number;
     readonly peerId: string;
@@ -25,7 +27,21 @@ declare class VertexState {
 }
 
 type TreeVertexId = string;
-type VertexPropertyType = string | number | boolean | string[] | number[] | boolean[] | undefined;
+/**
+ * Serializable CRDT data for operations
+ */
+interface CRDTType {
+    type: string;
+    value: Uint8Array;
+}
+/**
+ * Property type for state - includes Y.Doc for runtime usage
+ */
+type VertexPropertyType = string | number | boolean | string[] | number[] | boolean[] | undefined | Y.Doc;
+/**
+ * Property type for operations - includes CRDTType instead of Y.Doc
+ */
+type VertexPropertyTypeInOperation = string | number | boolean | string[] | number[] | boolean[] | undefined | CRDTType;
 type TreeVertexProperty = {
     readonly key: string;
     readonly value: VertexPropertyType;
@@ -67,15 +83,17 @@ interface SetVertexProperty {
     id: OpId;
     targetId: string;
     key: string;
-    value: VertexPropertyType;
+    value: VertexPropertyTypeInOperation;
     transient: boolean;
 }
 type VertexOperation = MoveVertex | SetVertexProperty;
 declare function isMoveVertexOp(op: VertexOperation): op is MoveVertex;
-declare function isSetPropertyOp(op: VertexOperation): op is SetVertexProperty;
+declare function isAnyPropertyOp(op: VertexOperation): op is SetVertexProperty;
+declare function isLWWPropertyOp(op: VertexOperation): op is SetVertexProperty;
+declare function isModifyPropertyOp(op: VertexOperation): op is SetVertexProperty;
 declare function newMoveVertexOp(clock: number, peerId: string, targetId: string, parentId: string | null): MoveVertex;
-declare function newSetVertexPropertyOp(clock: number, peerId: string, targetId: string, key: string, value: VertexPropertyType): SetVertexProperty;
-declare function newSetTransientVertexPropertyOp(clock: number, peerId: string, targetId: string, key: string, value: VertexPropertyType): SetVertexProperty;
+declare function newSetVertexPropertyOp(clock: number, peerId: string, targetId: string, key: string, value: VertexPropertyTypeInOperation): SetVertexProperty;
+declare function newSetTransientVertexPropertyOp(clock: number, peerId: string, targetId: string, key: string, value: VertexPropertyTypeInOperation): SetVertexProperty;
 
 /**
  * A wrapper class for VertexState that provides a more convenient API
@@ -122,7 +140,6 @@ declare class Vertex {
  */
 declare class RepTree {
     private static NULL_VERTEX_ID;
-    private static DEFAULT_MAX_DEPTH;
     readonly peerId: string;
     private rootVertexId;
     private lamportClock;
@@ -131,13 +148,13 @@ declare class RepTree {
     private setPropertyOps;
     private propertiesAndTheirOpIds;
     private transientPropertiesAndTheirOpIds;
+    private yjsObservers;
     private localOps;
     private pendingMovesWithMissingParent;
     private pendingPropertiesWithMissingVertex;
     private knownOps;
     private parentIdBeforeMove;
     private opAppliedCallbacks;
-    private maxDepth;
     private stateVector;
     private _stateVectorEnabled;
     /**
@@ -146,6 +163,7 @@ declare class RepTree {
      */
     constructor(peerId: string, ops?: ReadonlyArray<VertexOperation>);
     get root(): Vertex | undefined;
+    replicate(newPeerId: string): RepTree;
     getMoveOps(): ReadonlyArray<MoveVertex>;
     getAllOps(): ReadonlyArray<VertexOperation>;
     getVertex(vertexId: string): Vertex | undefined;
@@ -156,8 +174,11 @@ declare class RepTree {
     getAncestors(vertexId: string): Vertex[];
     getVertexProperty(vertexId: string, key: string, includingTransient?: boolean): VertexPropertyType | undefined;
     getVertexProperties(vertexId: string): Readonly<TreeVertexProperty[]>;
+    /**
+     * Returns all local operations and clears the local operations list.
+     * Can be used to get all operations that were generated from this peer and need to be sent to other peers.
+     */
     popLocalOps(): VertexOperation[];
-    setMaxDepth(maxDepth: number): void;
     createRoot(): Vertex;
     newVertex(parentId: string, props?: Record<string, VertexPropertyType> | object | null): Vertex;
     newNamedVertex(parentId: string, name: string, props?: Record<string, VertexPropertyType> | object | null): Vertex;
@@ -170,6 +191,7 @@ declare class RepTree {
     private getVertexByPathArray;
     printTree(): string;
     merge(ops: ReadonlyArray<VertexOperation>): void;
+    private applyOps;
     /** Applies operations in an optimized way, sorting move ops by OpId to avoid undo-do-redo cycles */
     private applyOpsOptimizedForLotsOfMoves;
     compareStructure(other: RepTree): boolean;
@@ -188,10 +210,13 @@ declare class RepTree {
     private updateLamportClock;
     private applyPendingMovesForParent;
     private applyMove;
-    private setPropertyAndItsOpId;
+    private setLLWPropertyAndItsOpId;
     private setTransientPropertyAndItsOpId;
+    private setupYjsObserver;
     private applyProperty;
-    private applyOps;
+    private applyLLWProperty;
+    private applyModifyProperty;
+    private applyOperation;
     private reportOpAsApplied;
     private tryToMove;
     private undoMove;
@@ -302,4 +327,4 @@ declare class StateVector {
 
 declare function uuid(): string;
 
-export { type MoveVertex, OpId, type OpIdRange, RepTree, type SetVertexProperty, StateVector, TreeState, type TreeVertexId, type TreeVertexProperty, Vertex, type VertexChangeEvent, type VertexChildrenChangeEvent, type VertexMoveEvent, type VertexOperation, type VertexPropertyChangeEvent, type VertexPropertyType, VertexState, isMoveVertexOp, isSetPropertyOp, newMoveVertexOp, newSetTransientVertexPropertyOp, newSetVertexPropertyOp, uuid };
+export { type CRDTType, type MoveVertex, OpId, type OpIdRange, RepTree, type SetVertexProperty, StateVector, TreeState, type TreeVertexId, type TreeVertexProperty, Vertex, type VertexChangeEvent, type VertexChildrenChangeEvent, type VertexMoveEvent, type VertexOperation, type VertexPropertyChangeEvent, type VertexPropertyType, type VertexPropertyTypeInOperation, VertexState, isAnyPropertyOp, isLWWPropertyOp, isModifyPropertyOp, isMoveVertexOp, newMoveVertexOp, newSetTransientVertexPropertyOp, newSetVertexPropertyOp, uuid };

package/dist/index.js

@@ -52,9 +52,15 @@ var OpId = class _OpId {
 function isMoveVertexOp(op) {
   return "parentId" in op;
 }
-function isSetPropertyOp(op) {
+function isAnyPropertyOp(op) {
   return "key" in op;
 }
+function isLWWPropertyOp(op) {
+  return "key" in op && "value" in op && (!op.value || typeof op.value !== "object" || !("type" in op.value));
+}
+function isModifyPropertyOp(op) {
+  return "key" in op && "value" in op && typeof op.value === "object" && op.value !== null && "type" in op.value;
+}
 function newMoveVertexOp(clock, peerId, targetId, parentId) {
   return { id: new OpId(clock, peerId), targetId, parentId };
 }
@@ -657,6 +663,7 @@ var StateVector = class _StateVector {
 };
 
 // src/RepTree.ts
+import * as Y from "yjs";
 var _RepTree = class _RepTree {
   /**
    * @param peerId - The peer ID of the current client. Should be unique across all peers.
@@ -668,13 +675,13 @@ var _RepTree = class _RepTree {
     this.setPropertyOps = [];
     this.propertiesAndTheirOpIds = /* @__PURE__ */ new Map();
     this.transientPropertiesAndTheirOpIds = /* @__PURE__ */ new Map();
+    this.yjsObservers = /* @__PURE__ */ new Map();
     this.localOps = [];
     this.pendingMovesWithMissingParent = /* @__PURE__ */ new Map();
     this.pendingPropertiesWithMissingVertex = /* @__PURE__ */ new Map();
     this.knownOps = /* @__PURE__ */ new Set();
     this.parentIdBeforeMove = /* @__PURE__ */ new Map();
     this.opAppliedCallbacks = [];
-    this.maxDepth = _RepTree.DEFAULT_MAX_DEPTH;
     this._stateVectorEnabled = true;
     this.peerId = peerId;
     this.state = new TreeState();
@@ -706,6 +713,9 @@ var _RepTree = class _RepTree {
     }
     return new Vertex(this, rootVertex);
   }
+  replicate(newPeerId) {
+    return new _RepTree(newPeerId, this.getAllOps());
+  }
   getMoveOps() {
     return this.moveOps;
   }
@@ -758,14 +768,15 @@ var _RepTree = class _RepTree {
     }
     return vertex.getAllProperties();
   }
+  /**
+   * Returns all local operations and clears the local operations list.
+   * Can be used to get all operations that were generated from this peer and need to be sent to other peers.
+   */
   popLocalOps() {
     const ops = this.localOps;
     this.localOps = [];
     return ops;
   }
-  setMaxDepth(maxDepth) {
-    this.maxDepth = maxDepth;
-  }
   createRoot() {
     if (this.rootVertexId) {
       throw new Error("Root vertex already exists");
@@ -813,13 +824,35 @@ var _RepTree = class _RepTree {
   }
   setTransientVertexProperty(vertexId, key, value) {
     this.lamportClock++;
-    const op = newSetTransientVertexPropertyOp(this.lamportClock, this.peerId, vertexId, key, value);
+    let opValue;
+    if (value instanceof Y.Doc) {
+      const state = Y.encodeStateAsUpdate(value);
+      opValue = {
+        type: "yjs",
+        value: state
+      };
+      this.setupYjsObserver(value, vertexId, key);
+    } else {
+      opValue = value;
+    }
+    const op = newSetTransientVertexPropertyOp(this.lamportClock, this.peerId, vertexId, key, opValue);
     this.localOps.push(op);
     this.applyProperty(op);
   }
   setVertexProperty(vertexId, key, value) {
     this.lamportClock++;
-    const op = newSetVertexPropertyOp(this.lamportClock, this.peerId, vertexId, key, value);
+    let opValue;
+    if (value instanceof Y.Doc) {
+      const state = Y.encodeStateAsUpdate(value);
+      opValue = {
+        type: "yjs",
+        value: state
+      };
+      this.setupYjsObserver(value, vertexId, key);
+    } else {
+      opValue = value;
+    }
+    const op = newSetVertexPropertyOp(this.lamportClock, this.peerId, vertexId, key, opValue);
     this.localOps.push(op);
     this.applyProperty(op);
   }
@@ -865,6 +898,14 @@ var _RepTree = class _RepTree {
   merge(ops) {
     this.applyOps(ops);
   }
+  applyOps(ops) {
+    for (const op of ops) {
+      if (this.knownOps.has(op.id.toString())) {
+        continue;
+      }
+      this.applyOperation(op);
+    }
+  }
   /** Applies operations in an optimized way, sorting move ops by OpId to avoid undo-do-redo cycles */
   applyOpsOptimizedForLotsOfMoves(ops) {
     const newMoveOps = ops.filter((op) => isMoveVertexOp(op) && !this.knownOps.has(op.id.toString()));
@@ -876,7 +917,7 @@ var _RepTree = class _RepTree {
         this.applyMove(op);
       }
     }
-    const propertyOps = ops.filter((op) => isSetPropertyOp(op) && !this.knownOps.has(op.id.toString()));
+    const propertyOps = ops.filter((op) => isAnyPropertyOp(op) && !this.knownOps.has(op.id.toString()));
     for (let i = 0, len = propertyOps.length; i < len; i++) {
       const op = propertyOps[i];
       this.applyProperty(op);
@@ -908,16 +949,16 @@ var _RepTree = class _RepTree {
   isAncestor(childId, ancestorId) {
     let targetId = childId;
     let vertex;
-    let depth = 0;
+    const visitedVertices = /* @__PURE__ */ new Set();
     while (vertex = this.state.getVertex(targetId)) {
       if (vertex.parentId === ancestorId) return true;
       if (!vertex.parentId) return false;
-      if (depth > this.maxDepth) {
-        console.error(`isAncestor: max depth of ${this.maxDepth} reached. Perhaps, we have an infinite loop here.`);
-        return true;
+      if (visitedVertices.has(targetId)) {
+        console.error(`isAncestor: cycle detected in the tree structure.`);
+        return false;
       }
+      visitedVertices.add(targetId);
       targetId = vertex.parentId;
-      depth++;
     }
     return false;
   }
@@ -971,7 +1012,16 @@ var _RepTree = class _RepTree {
       }
       for (const propA of propertiesA) {
         const propB = propertiesB.find((p) => p.key === propA.key);
-        if (!propB || propA.value !== propB.value) {
+        if (!propB) {
+          return false;
+        }
+        if (propA.value instanceof Y.Doc && propB.value instanceof Y.Doc) {
+          const snapshotA = Y.snapshot(propA.value);
+          const snapshotB = Y.snapshot(propB.value);
+          if (!Y.equalSnapshots(snapshotA, snapshotB)) {
+            return false;
+          }
+        } else if (propA.value !== propB.value) {
           return false;
         }
       }
@@ -1058,7 +1108,7 @@ var _RepTree = class _RepTree {
     }
     this.applyPendingMovesForParent(op.targetId);
   }
-  setPropertyAndItsOpId(op) {
+  setLLWPropertyAndItsOpId(op) {
     this.propertiesAndTheirOpIds.set(`${op.key}@${op.targetId}`, op.id);
     this.state.setProperty(op.targetId, op.key, op.value);
     this.reportOpAsApplied(op);
@@ -1068,6 +1118,40 @@ var _RepTree = class _RepTree {
     this.state.setTransientProperty(op.targetId, op.key, op.value);
     this.reportOpAsApplied(op);
   }
+  setupYjsObserver(doc, vertexId, key) {
+    const propertyKey = `${key}@${vertexId}`;
+    if (this.yjsObservers.has(propertyKey)) {
+      const existingDoc = this.getVertexProperty(vertexId, key);
+      if (existingDoc instanceof Y.Doc) {
+        existingDoc.off("update", this.yjsObservers.get(propertyKey));
+      }
+      this.yjsObservers.delete(propertyKey);
+    }
+    const ydocObserver = (update, origin, doc2, transaction) => {
+      if (!transaction.local) {
+        return;
+      }
+      const crdtValue = {
+        type: "yjs",
+        value: update
+      };
+      this.lamportClock++;
+      const op = newSetVertexPropertyOp(
+        this.lamportClock,
+        this.peerId,
+        vertexId,
+        key,
+        crdtValue
+      );
+      this.localOps.push(op);
+      this.applyProperty(op);
+      if (this._stateVectorEnabled) {
+        this.stateVector.updateFromOp(op);
+      }
+    };
+    doc.on("update", ydocObserver);
+    this.yjsObservers.set(propertyKey, ydocObserver);
+  }
   applyProperty(op) {
     const targetVertex = this.state.getVertex(op.targetId);
     if (!targetVertex) {
@@ -1081,13 +1165,20 @@ var _RepTree = class _RepTree {
       return;
     }
     this.updateLamportClock(op);
+    if (isModifyPropertyOp(op)) {
+      this.applyModifyProperty(op, targetVertex);
+    } else {
+      this.applyLLWProperty(op, targetVertex);
+    }
+  }
+  applyLLWProperty(op, targetVertex) {
     const prevTransientOpId = this.transientPropertiesAndTheirOpIds.get(`${op.key}@${op.targetId}`);
     const prevProp = targetVertex.getProperty(op.key);
     const prevOpId = this.propertiesAndTheirOpIds.get(`${op.key}@${op.targetId}`);
     if (!op.transient) {
       this.setPropertyOps.push(op);
       if (!prevProp || !prevOpId || op.id.isGreaterThan(prevOpId)) {
-        this.setPropertyAndItsOpId(op);
+        this.setLLWPropertyAndItsOpId(op);
       } else {
         this.knownOps.add(op.id.toString());
       }
@@ -1101,16 +1192,33 @@ var _RepTree = class _RepTree {
       }
     }
   }
-  applyOps(ops) {
-    for (const op of ops) {
-      if (this.knownOps.has(op.id.toString())) {
-        continue;
-      }
-      if (isMoveVertexOp(op)) {
-        this.applyMove(op);
-      } else if (isSetPropertyOp(op)) {
-        this.applyProperty(op);
-      }
+  applyModifyProperty(op, targetVertex) {
+    if (op.transient) {
+      console.warn("Not implemented: transient non LWW property");
+      return;
+    }
+    this.setPropertyOps.push(op);
+    const crdtValue = op.value;
+    if (crdtValue.type !== "yjs") {
+      throw new Error("Unknown CRDT type");
+    }
+    const ydoc = targetVertex.getProperty(op.key);
+    if (ydoc instanceof Y.Doc) {
+      Y.applyUpdate(ydoc, crdtValue.value);
+    } else {
+      const newDoc = new Y.Doc();
+      this.setupYjsObserver(newDoc, op.targetId, op.key);
+      this.state.setProperty(op.targetId, op.key, newDoc);
+      Y.applyUpdate(newDoc, crdtValue.value);
+    }
+    this.propertiesAndTheirOpIds.set(`${op.key}@${op.targetId}`, op.id);
+    this.reportOpAsApplied(op);
+  }
+  applyOperation(op) {
+    if (isMoveVertexOp(op)) {
+      this.applyMove(op);
+    } else if (isAnyPropertyOp(op)) {
+      this.applyProperty(op);
     }
   }
   reportOpAsApplied(op) {
@@ -1134,7 +1242,7 @@ var _RepTree = class _RepTree {
       const pendingProperties = this.pendingPropertiesWithMissingVertex.get(op.targetId) || [];
       this.pendingPropertiesWithMissingVertex.delete(op.targetId);
       for (const prop of pendingProperties) {
-        this.setPropertyAndItsOpId(prop);
+        this.applyProperty(prop);
       }
     }
   }
@@ -1209,7 +1317,6 @@ var _RepTree = class _RepTree {
   }
 };
 _RepTree.NULL_VERTEX_ID = "0";
-_RepTree.DEFAULT_MAX_DEPTH = 1e5;
 var RepTree = _RepTree;
 export {
   OpId,
@@ -1218,8 +1325,10 @@ export {
   TreeState,
   Vertex,
   VertexState,
+  isAnyPropertyOp,
+  isLWWPropertyOp,
+  isModifyPropertyOp,
   isMoveVertexOp,
-  isSetPropertyOp,
   newMoveVertexOp,
   newSetTransientVertexPropertyOp,
   newSetVertexPropertyOp,