reptree 0.1.0

package/dist/index.js

@@ -0,0 +1,942 @@
+// src/OpId.ts
+var OpId = class _OpId {
+  constructor(counter, peerId) {
+    this.counter = counter;
+    this.peerId = peerId;
+  }
+  static compare(opIdA, opIdB) {
+    if (!(opIdA instanceof _OpId)) {
+      const parsedA = _OpId.tryParseStr(opIdA);
+      if (!parsedA) throw new Error(`Invalid OpId string: ${opIdA}`);
+      opIdA = parsedA;
+    }
+    if (!(opIdB instanceof _OpId)) {
+      const parsedB = _OpId.tryParseStr(opIdB);
+      if (!parsedB) throw new Error(`Invalid OpId string: ${opIdB}`);
+      opIdB = parsedB;
+    }
+    const counterA = opIdA.counter;
+    const counterB = opIdB.counter;
+    if (counterA > counterB) {
+      return 1;
+    } else if (counterA < counterB) {
+      return -1;
+    } else {
+      return opIdA.peerId.localeCompare(opIdB.peerId);
+    }
+  }
+  static equals(opIdA, opIdB) {
+    if (opIdA === opIdB) {
+      return true;
+    } else if (!opIdA || !opIdB) {
+      return false;
+    }
+    return _OpId.compare(opIdA, opIdB) === 0;
+  }
+  static tryParseStr(opIdStr) {
+    const parts = opIdStr.split("@");
+    if (parts.length !== 2) {
+      throw new Error(`Invalid OpId string: ${opIdStr}`);
+    }
+    return new _OpId(parseInt(parts[0], 10), parts[1]);
+  }
+  isGreaterThan(opId) {
+    return _OpId.compare(this, opId) === 1;
+  }
+  toString() {
+    return `${this.counter}@${this.peerId}`;
+  }
+};
+
+// src/operations.ts
+function isMoveVertexOp(op) {
+  return "parentId" in op;
+}
+function isSetPropertyOp(op) {
+  return "key" in op;
+}
+function newMoveVertexOp(clock, peerId, targetId, parentId) {
+  return { id: new OpId(clock, peerId), targetId, parentId };
+}
+function newSetVertexPropertyOp(clock, peerId, targetId, key, value) {
+  return { id: new OpId(clock, peerId), targetId, key, value, transient: false };
+}
+function newSetTransientVertexPropertyOp(clock, peerId, targetId, key, value) {
+  return { id: new OpId(clock, peerId), targetId, key, value, transient: true };
+}
+
+// src/VertexState.ts
+var VertexState = class {
+  constructor(id, parentId) {
+    this.id = id;
+    this.parentId = parentId;
+    this.properties = [];
+    this.transientProperties = [];
+    this.children = [];
+  }
+  setProperty(key, value) {
+    const existingPropIndex = this.properties.findIndex((p) => p.key === key);
+    if (existingPropIndex !== -1) {
+      if (value !== void 0) {
+        this.properties[existingPropIndex] = { key, value };
+      } else {
+        this.removeProperty(key);
+      }
+    } else {
+      if (value !== void 0) {
+        this.properties.push({ key, value });
+      }
+    }
+  }
+  setTransientProperty(key, value) {
+    const existingPropIndex = this.transientProperties.findIndex((p) => p.key === key);
+    if (existingPropIndex !== -1) {
+      if (value !== void 0) {
+        this.transientProperties[existingPropIndex] = { key, value };
+      } else {
+        this.removeTransientProperty(key);
+      }
+    } else {
+      if (value !== void 0) {
+        this.transientProperties.push({ key, value });
+      }
+    }
+  }
+  getProperty(key, includingTransient = true) {
+    if (includingTransient) {
+      const transientProp = this.transientProperties.find((p) => p.key === key);
+      if (transientProp) {
+        return transientProp.value;
+      }
+    }
+    return this.properties.find((p) => p.key === key)?.value;
+  }
+  getAllProperties(includingTransient = true) {
+    if (!includingTransient) {
+      return this.properties;
+    }
+    const result = [];
+    const seenKeys = /* @__PURE__ */ new Set();
+    for (const prop of this.transientProperties) {
+      result.push(prop);
+      seenKeys.add(prop.key);
+    }
+    for (const prop of this.properties) {
+      if (!seenKeys.has(prop.key)) {
+        result.push(prop);
+      }
+    }
+    return result;
+  }
+  removeProperty(key) {
+    this.properties = this.properties.filter((p) => p.key !== key);
+  }
+  removeTransientProperty(key) {
+    this.transientProperties = this.transientProperties.filter((p) => p.key !== key);
+  }
+};
+
+// src/TreeState.ts
+var TreeState = class {
+  constructor() {
+    this.changeCallbacks = /* @__PURE__ */ new Map();
+    this.globalChangeCallbacks = /* @__PURE__ */ new Set();
+    this.batchedEvents = /* @__PURE__ */ new Map();
+    this.vertices = /* @__PURE__ */ new Map();
+    this.batchTickInterval = setInterval(() => {
+      this.processBatchedEvents();
+    }, 33.3);
+  }
+  dispose() {
+    clearInterval(this.batchTickInterval);
+  }
+  processBatchedEvents() {
+    for (const [vertexId, events] of this.batchedEvents) {
+      let lastMoveEvent = null;
+      let lastChildrenEvent = null;
+      const propertyEventsByKey = /* @__PURE__ */ new Map();
+      for (let i = events.length - 1; i >= 0; i--) {
+        const event = events[i];
+        if (!lastMoveEvent && event.type === "move") lastMoveEvent = event;
+        if (!lastChildrenEvent && event.type === "children") lastChildrenEvent = event;
+        if (event.type === "property") {
+          const propertyEvent = event;
+          if (!propertyEventsByKey.has(propertyEvent.key)) {
+            propertyEventsByKey.set(propertyEvent.key, propertyEvent);
+          }
+        }
+      }
+      const filteredEvents = [
+        ...lastMoveEvent ? [lastMoveEvent] : [],
+        ...lastChildrenEvent ? [lastChildrenEvent] : [],
+        ...propertyEventsByKey.values()
+      ];
+      this.globalChangeCallbacks.forEach((listener) => listener(filteredEvents));
+      this.changeCallbacks.get(vertexId)?.forEach((listener) => listener(filteredEvents));
+    }
+    this.batchedEvents.clear();
+  }
+  getAllVertices() {
+    return Array.from(this.vertices.values());
+  }
+  getVertex(id) {
+    return this.vertices.get(id);
+  }
+  getChildrenIds(vertexId) {
+    return this.getVertex(vertexId)?.children ?? [];
+  }
+  getChildren(vertexId) {
+    return this.getChildrenIds(vertexId).map((id) => {
+      const vertex = this.vertices.get(id);
+      return vertex ? vertex : void 0;
+    }).filter((vertex) => vertex !== void 0).sort((a, b) => {
+      const aDate = a.getProperty("_c");
+      const bDate = b.getProperty("_c");
+      if (!aDate) return -1;
+      if (!bDate) return 1;
+      return new Date(aDate).getTime() - new Date(bDate).getTime();
+    });
+  }
+  moveVertex(vertexId, newParentId) {
+    let vertex = this.getVertex(vertexId);
+    const prevParentId = vertex ? vertex.parentId : void 0;
+    if (!vertex) {
+      vertex = new VertexState(vertexId, newParentId);
+      this.vertices.set(vertexId, vertex);
+    }
+    if (prevParentId === newParentId) {
+      return vertex;
+    }
+    vertex.parentId = newParentId;
+    let childrenInNewParent = null;
+    let childrenInOldParent = null;
+    if (prevParentId) {
+      const oldParentVertex = this.getVertex(prevParentId);
+      if (oldParentVertex) {
+        oldParentVertex.children = oldParentVertex.children.filter((child) => child !== vertexId);
+        childrenInOldParent = oldParentVertex.children;
+      } else {
+        console.error(`Old parent vertex not found for ${prevParentId}`);
+      }
+    }
+    if (newParentId !== null) {
+      const newParentVertex = this.vertices.get(newParentId);
+      if (newParentVertex) {
+        newParentVertex.children.push(vertexId);
+        childrenInNewParent = newParentVertex.children;
+      } else {
+        console.error(`New parent vertex not found for ${newParentId}`);
+      }
+    }
+    this.notifyChange({
+      type: "move",
+      vertexId,
+      oldParentId: prevParentId,
+      newParentId
+    });
+    if (childrenInNewParent !== null && newParentId !== null) {
+      this.notifyChange({
+        type: "children",
+        vertexId: newParentId,
+        children: childrenInNewParent.map((id) => this.vertices.get(id))
+      });
+    }
+    if (childrenInOldParent !== null && prevParentId) {
+      this.notifyChange({
+        type: "children",
+        vertexId: prevParentId,
+        children: childrenInOldParent.map((id) => this.vertices.get(id))
+      });
+    }
+    return vertex;
+  }
+  setProperty(vertexId, key, value) {
+    const vertex = this.getVertex(vertexId);
+    if (!vertex) {
+      throw new Error(`Vertex ${vertexId} not found`);
+    }
+    vertex.setProperty(key, value);
+    this.notifyChange({
+      type: "property",
+      vertexId,
+      key,
+      value
+    });
+    if (vertex.parentId !== null) {
+      this.notifyChange({
+        type: "children",
+        vertexId: vertex.parentId,
+        children: [vertex]
+        // @TODO: shoulld I set all children or rename this property?
+      });
+    }
+  }
+  setTransientProperty(vertexId, key, value) {
+    const vertex = this.getVertex(vertexId);
+    if (vertex) {
+      vertex.setTransientProperty(key, value);
+    }
+    this.notifyChange({
+      type: "property",
+      vertexId,
+      key,
+      value
+    });
+  }
+  addChangeCallback(vertexId, listener) {
+    if (!this.changeCallbacks.has(vertexId)) {
+      this.changeCallbacks.set(vertexId, /* @__PURE__ */ new Set());
+    }
+    this.changeCallbacks.get(vertexId).add(listener);
+  }
+  removeChangeCallback(vertexId, listener) {
+    this.changeCallbacks.get(vertexId)?.delete(listener);
+  }
+  addGlobalChangeCallback(listener) {
+    this.globalChangeCallbacks.add(listener);
+  }
+  removeGlobalChangeCallback(listener) {
+    this.globalChangeCallbacks.delete(listener);
+  }
+  notifyChange(event) {
+    let events = this.batchedEvents.get(event.vertexId);
+    if (!events) {
+      events = [];
+      this.batchedEvents.set(event.vertexId, events);
+    }
+    events.push(event);
+  }
+  printTree(vertexId, indent = "", isLast = true) {
+    const prefix = indent + (isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ");
+    let result = prefix + vertexId + "\n";
+    let vertexName = null;
+    if (vertexId !== null) {
+      const vertex = this.getVertex(vertexId);
+      if (vertex) {
+        for (const prop of vertex.getAllProperties()) {
+          if (prop.key === "_n") {
+            vertexName = prop.value;
+          }
+          const propPrefix = indent + (isLast ? "    " : "\u2502   ") + "\u2022 ";
+          result += `${propPrefix}${prop.key}: ${JSON.stringify(prop.value)}
+`;
+        }
+      }
+    }
+    const children = this.getChildrenIds(vertexId);
+    for (let i = 0; i < children.length; i++) {
+      const childId = children[i];
+      const isLastChild = i === children.length - 1;
+      result += this.printTree(childId, indent + (isLast ? "    " : "\u2502   "), isLastChild);
+    }
+    return result;
+  }
+};
+
+// src/uuid.ts
+var removeDashes = (guid) => guid.replace(/-/g, "");
+function uuid() {
+  return removeDashes(crypto.randomUUID());
+}
+
+// src/Vertex.ts
+var Vertex = class {
+  constructor(tree, state) {
+    this.tree = tree;
+    this.state = state;
+  }
+  get id() {
+    return this.state.id;
+  }
+  get name() {
+    return this.getProperty("_n");
+  }
+  set name(name) {
+    this.tree.setVertexProperty(this.id, "_n", name);
+  }
+  get createdAt() {
+    const createdAt = this.getProperty("_c");
+    if (!createdAt) {
+      return /* @__PURE__ */ new Date(0);
+    }
+    return new Date(createdAt);
+  }
+  get path() {
+    throw new Error("Not implemented");
+  }
+  get parentId() {
+    return this.state.parentId;
+  }
+  get parent() {
+    if (!this.parentId) {
+      return void 0;
+    }
+    return this.tree.getVertex(this.parentId);
+  }
+  get children() {
+    return this.tree.getChildren(this.id);
+  }
+  get childrenIds() {
+    return this.tree.getChildrenIds(this.id);
+  }
+  getAsTypedObject() {
+    return this.getProperties();
+  }
+  getChildrenAsTypedArray() {
+    return this.children.map((v) => v.getAsTypedObject());
+  }
+  newChild(props) {
+    const typedProps = props;
+    return this.tree.newVertex(this.id, typedProps);
+  }
+  newNamedChild(name, props) {
+    const typedProps = props;
+    return this.tree.newNamedVertex(this.id, name, typedProps);
+  }
+  setProperty(key, value) {
+    const existingValue = this.getProperty(key, false);
+    if (existingValue === value) {
+      return;
+    }
+    this.tree.setVertexProperty(this.id, key, value);
+  }
+  setTransientProperty(key, value) {
+    const existingValue = this.getProperty(key);
+    if (existingValue === value) {
+      return;
+    }
+    this.tree.setTransientVertexProperty(this.id, key, value);
+  }
+  setProperties(props) {
+    for (const [key, value] of Object.entries(props)) {
+      this.setProperty(key, value);
+    }
+  }
+  getProperty(key, includingTransient = true) {
+    return this.tree.getVertexProperty(this.id, key, includingTransient);
+  }
+  getProperties() {
+    const props = {};
+    this.tree.getVertexProperties(this.id).forEach((p) => {
+      props[p.key] = p.value;
+    });
+    return props;
+  }
+  findAllChildrenWithProperty(key, value) {
+    return this.children.filter((c) => c.getProperty(key) === value);
+  }
+  findFirstChildVertexWithProperty(key, value) {
+    return this.children.find((c) => c.getProperty(key) === value);
+  }
+  findFirstTypedChildWithProperty(key, value) {
+    return this.findFirstChildVertexWithProperty(key, value)?.getAsTypedObject();
+  }
+  findAllTypedChildrenWithProperty(key, value) {
+    return this.findAllChildrenWithProperty(key, value).map((c) => c.getAsTypedObject());
+  }
+  observe(listener) {
+    const unobserve = this.tree.observe(this.id, listener);
+    return () => unobserve();
+  }
+  observeChildren(listener) {
+    const unobserve = this.tree.observe(this.id, (events) => {
+      if (events.some((e) => e.type === "children")) {
+        listener(this.children);
+      }
+    });
+    return () => unobserve();
+  }
+  observeChildrenAsTypedArray(listener) {
+    return this.observeChildren((children) => {
+      listener(children.map((c) => c.getProperties()));
+    });
+  }
+  delete() {
+    this.tree.deleteVertex(this.id);
+  }
+  moveTo(parent) {
+    this.tree.moveVertex(this.id, parent.id);
+  }
+};
+
+// src/RepTree.ts
+var _RepTree = class _RepTree {
+  /**
+   * @param peerId - The peer ID of the current client
+   * @param ops - The operations to replicate an existing tree, if null - a new tree will be created
+   */
+  constructor(peerId, ops = null) {
+    this.lamportClock = 0;
+    this.moveOps = [];
+    this.setPropertyOps = [];
+    this.propertiesAndTheirOpIds = /* @__PURE__ */ new Map();
+    this.transientPropertiesAndTheirOpIds = /* @__PURE__ */ new Map();
+    this.localOps = [];
+    this.pendingMovesWithMissingParent = /* @__PURE__ */ new Map();
+    this.pendingPropertiesWithMissingVertex = /* @__PURE__ */ new Map();
+    this.appliedOps = /* @__PURE__ */ new Set();
+    this.parentIdBeforeMove = /* @__PURE__ */ new Map();
+    this.opAppliedCallbacks = [];
+    this.maxDepth = _RepTree.DEFAULT_MAX_DEPTH;
+    this.peerId = peerId;
+    this.state = new TreeState();
+    if (ops != null && ops.length > 0) {
+      let rootMoveOp;
+      for (let i = 0; i < ops.length; i++) {
+        if (isMoveVertexOp(ops[i]) && ops[i].parentId === null) {
+          rootMoveOp = ops[i];
+          break;
+        }
+      }
+      if (rootMoveOp) {
+        this.rootVertexId = rootMoveOp.targetId;
+      } else {
+        throw new Error("The operations has to contain a move operation with a parentId as null to set the root vertex");
+      }
+      this.applyOps(ops);
+      this.ensureTrashVertex();
+    } else {
+      this.rootVertexId = this.newVertexInternalWithUUID(null);
+      this.ensureTrashVertex();
+    }
+  }
+  getMoveOps() {
+    return this.moveOps;
+  }
+  getAllOps() {
+    return [...this.moveOps, ...this.setPropertyOps];
+  }
+  getVertex(vertexId) {
+    const vertex = this.state.getVertex(vertexId);
+    return vertex ? new Vertex(this, vertex) : void 0;
+  }
+  get rootVertex() {
+    const rootVertex = this.state.getVertex(this.rootVertexId);
+    if (!rootVertex) {
+      throw new Error("Root vertex not found");
+    }
+    return new Vertex(this, rootVertex);
+  }
+  getAllVertices() {
+    return this.state.getAllVertices().map((v) => new Vertex(this, v));
+  }
+  getParent(vertexId) {
+    const parentId = this.state.getVertex(vertexId)?.parentId;
+    const parent = parentId ? this.state.getVertex(parentId) : void 0;
+    return parent ? new Vertex(this, parent) : void 0;
+  }
+  getChildren(vertexId) {
+    return this.state.getChildren(vertexId).map((v) => new Vertex(this, v));
+  }
+  getChildrenIds(vertexId) {
+    return this.state.getChildrenIds(vertexId);
+  }
+  getAncestors(vertexId) {
+    const ancestors = [];
+    let currentVertex = this.state.getVertex(vertexId);
+    while (currentVertex && currentVertex.parentId) {
+      const parentVertex = this.state.getVertex(currentVertex.parentId);
+      if (parentVertex) {
+        ancestors.push(new Vertex(this, parentVertex));
+        currentVertex = parentVertex;
+      } else {
+        break;
+      }
+    }
+    return ancestors;
+  }
+  getVertexProperty(vertexId, key, includingTransient = true) {
+    const vertex = this.state.getVertex(vertexId);
+    if (!vertex) {
+      return void 0;
+    }
+    return vertex.getProperty(key, includingTransient);
+  }
+  getVertexProperties(vertexId) {
+    const vertex = this.state.getVertex(vertexId);
+    if (!vertex) {
+      return [];
+    }
+    return vertex.getAllProperties();
+  }
+  popLocalOps() {
+    const ops = this.localOps;
+    this.localOps = [];
+    return ops;
+  }
+  setMaxDepth(maxDepth) {
+    this.maxDepth = maxDepth;
+  }
+  newVertex(parentId, props = null) {
+    const typedProps = props;
+    const vertexId = this.newVertexInternalWithUUID(parentId);
+    if (typedProps) {
+      this.setVertexProperties(vertexId, typedProps);
+    }
+    const vertex = this.state.getVertex(vertexId);
+    if (!vertex) {
+      throw new Error("Failed to create vertex");
+    }
+    return new Vertex(this, vertex);
+  }
+  newNamedVertex(parentId, name, props = null) {
+    const typedProps = props;
+    const vertexId = this.newVertexInternalWithUUID(parentId);
+    if (typedProps) {
+      this.setVertexProperties(vertexId, typedProps);
+    }
+    this.setVertexProperty(vertexId, "_n", name);
+    const vertex = this.state.getVertex(vertexId);
+    if (!vertex) {
+      throw new Error("Failed to create named vertex");
+    }
+    return new Vertex(this, vertex);
+  }
+  moveVertex(vertexId, parentId) {
+    this.lamportClock++;
+    const op = newMoveVertexOp(this.lamportClock, this.peerId, vertexId, parentId);
+    this.localOps.push(op);
+    this.applyMove(op);
+  }
+  deleteVertex(vertexId) {
+    this.moveVertex(vertexId, _RepTree.TRASH_VERTEX_ID);
+  }
+  setTransientVertexProperty(vertexId, key, value) {
+    this.lamportClock++;
+    const op = newSetTransientVertexPropertyOp(this.lamportClock, this.peerId, vertexId, key, value);
+    this.localOps.push(op);
+    this.applyProperty(op);
+  }
+  setVertexProperty(vertexId, key, value) {
+    this.lamportClock++;
+    const op = newSetVertexPropertyOp(this.lamportClock, this.peerId, vertexId, key, value);
+    this.localOps.push(op);
+    this.applyProperty(op);
+  }
+  setVertexProperties(vertexId, props) {
+    const typedProps = props;
+    for (const [key, value] of Object.entries(typedProps)) {
+      this.setVertexProperty(vertexId, key, value);
+    }
+  }
+  getVertexByPath(path) {
+    path = path.replace(/^\/+/, "");
+    path = path.replace(/\/+$/, "");
+    const pathParts = path.split("/");
+    const root = this.state.getVertex(this.rootVertexId);
+    if (!root) {
+      throw new Error("The root vertex is not found");
+    }
+    const vertex = this.getVertexByPathArray(new Vertex(this, root), pathParts);
+    return vertex;
+  }
+  getVertexByPathArray(vertex, path) {
+    if (path.length === 0) {
+      return vertex ?? void 0;
+    }
+    const targetName = path[0];
+    const children = this.getChildren(vertex.id);
+    for (const child of children) {
+      if (child.getProperty("_n") === targetName) {
+        return this.getVertexByPathArray(child, path.slice(1));
+      }
+    }
+    return void 0;
+  }
+  printTree() {
+    return this.state.printTree(this.rootVertexId);
+  }
+  merge(ops) {
+    this.applyOps(ops);
+  }
+  compareStructure(other) {
+    return _RepTree.compareVertices(this.rootVertexId, this, other);
+  }
+  compareMoveOps(other) {
+    const movesA = this.moveOps;
+    const movesB = other.getMoveOps();
+    if (movesA.length !== movesB.length) {
+      return false;
+    }
+    for (let i = 0; i < movesA.length; i++) {
+      if (!OpId.equals(movesA[i].id, movesB[i].id)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /** Checks if the given `ancestorId` is an ancestor of `childId` in the tree */
+  isAncestor(childId, ancestorId) {
+    let targetId = childId;
+    let vertex;
+    let depth = 0;
+    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;
+      }
+      targetId = vertex.parentId;
+      depth++;
+    }
+    return false;
+  }
+  observeVertex(vertexId, callback) {
+    const vertex = this.getVertex(vertexId);
+    if (vertex) {
+      callback(vertex);
+    }
+    const unsubscribe = this.observe(vertexId, (_) => {
+      const vertex2 = this.getVertex(vertexId);
+      if (vertex2) {
+        callback(vertex2);
+      }
+    });
+    return () => {
+      unsubscribe();
+    };
+  }
+  observeVertexMove(callback) {
+    const listener = (events) => {
+      const moveEvent = events.find((e) => e.type === "move");
+      if (moveEvent) {
+        const vertex = this.getVertex(moveEvent.vertexId);
+        if (vertex) {
+          callback(vertex, moveEvent.oldParentId === void 0);
+        }
+      }
+    };
+    this.state.addGlobalChangeCallback(listener);
+    return () => this.state.removeGlobalChangeCallback(listener);
+  }
+  observe(vertexId, callback) {
+    this.state.addChangeCallback(vertexId, callback);
+    return () => this.state.removeChangeCallback(vertexId, callback);
+  }
+  observeOpApplied(callback) {
+    this.opAppliedCallbacks.push(callback);
+    return () => this.opAppliedCallbacks = this.opAppliedCallbacks.filter((l) => l !== callback);
+  }
+  static compareVertices(vertexId, treeA, treeB) {
+    const childrenA = treeA.state.getChildrenIds(vertexId);
+    const childrenB = treeB.state.getChildrenIds(vertexId);
+    if (childrenA.length !== childrenB.length) {
+      return false;
+    }
+    if (vertexId !== null) {
+      const propertiesA = treeA.getVertexProperties(vertexId);
+      const propertiesB = treeB.getVertexProperties(vertexId);
+      if (propertiesA.length !== propertiesB.length) {
+        return false;
+      }
+      for (const propA of propertiesA) {
+        const propB = propertiesB.find((p) => p.key === propA.key);
+        if (!propB || propA.value !== propB.value) {
+          return false;
+        }
+      }
+    }
+    for (const childId of childrenA) {
+      if (!childrenB.includes(childId)) {
+        return false;
+      }
+      if (!_RepTree.compareVertices(childId, treeA, treeB)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  newVertexInternal(vertexId, parentId) {
+    this.lamportClock++;
+    const op = newMoveVertexOp(this.lamportClock, this.peerId, vertexId, parentId);
+    this.localOps.push(op);
+    this.applyMove(op);
+    this.setVertexProperty(vertexId, "_c", (/* @__PURE__ */ new Date()).toISOString());
+    return vertexId;
+  }
+  newVertexInternalWithUUID(parentId) {
+    const vertexId = uuid();
+    return this.newVertexInternal(vertexId, parentId);
+  }
+  ensureTrashVertex() {
+    const vertexId = _RepTree.TRASH_VERTEX_ID;
+    if (this.state.getVertex(vertexId)) {
+      return;
+    }
+    this.newVertexInternal(vertexId, null);
+  }
+  /** Updates the lamport clock with the counter value of the operation */
+  updateLamportClock(operation) {
+    if (operation.id.counter > this.lamportClock) {
+      this.lamportClock = operation.id.counter;
+    }
+  }
+  applyMove(op) {
+    if (op.parentId !== null && !this.state.getVertex(op.parentId)) {
+      if (!this.pendingMovesWithMissingParent.has(op.parentId)) {
+        this.pendingMovesWithMissingParent.set(op.parentId, []);
+      }
+      this.pendingMovesWithMissingParent.get(op.parentId).push(op);
+      return;
+    }
+    this.updateLamportClock(op);
+    const lastOp = this.moveOps.length > 0 ? this.moveOps[this.moveOps.length - 1] : null;
+    if (lastOp === null || op.id.isGreaterThan(lastOp.id)) {
+      this.moveOps.push(op);
+      this.reportOpAsApplied(op);
+      this.tryToMove(op);
+    } else {
+      let targetIndex = this.moveOps.length;
+      for (let i = this.moveOps.length - 1; i >= 0; i--) {
+        const moveOp = this.moveOps[i];
+        targetIndex = i;
+        if (op.id.isGreaterThan(moveOp.id)) {
+          break;
+        } else {
+          this.undoMove(moveOp);
+        }
+      }
+      this.moveOps.splice(targetIndex + 1, 0, op);
+      this.reportOpAsApplied(op);
+      this.tryToMove(op);
+      for (let i = targetIndex + 2; i < this.moveOps.length; i++) {
+        this.tryToMove(this.moveOps[i]);
+      }
+    }
+    this.applyPendingMovesForParent(op.targetId);
+  }
+  reportOpAsApplied(op) {
+    this.appliedOps.add(op.id.toString());
+    for (const callback of this.opAppliedCallbacks) {
+      callback(op);
+    }
+  }
+  applyOps(ops) {
+    for (const op of ops) {
+      if (this.appliedOps.has(op.id.toString())) {
+        continue;
+      }
+      if (isMoveVertexOp(op)) {
+        this.applyMove(op);
+      } else if (isSetPropertyOp(op)) {
+        this.applyProperty(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.appliedOps.has(op.id.toString()));
+    if (newMoveOps.length > 0) {
+      const allMoveOps = [...this.moveOps, ...newMoveOps];
+      allMoveOps.sort((a, b) => OpId.compare(a.id, b.id));
+      for (let i = 0, len = allMoveOps.length; i < len; i++) {
+        const op = allMoveOps[i];
+        this.applyMove(op);
+      }
+    }
+    const propertyOps = ops.filter((op) => isSetPropertyOp(op) && !this.appliedOps.has(op.id.toString()));
+    for (let i = 0, len = propertyOps.length; i < len; i++) {
+      const op = propertyOps[i];
+      this.applyProperty(op);
+    }
+  }
+  applyPendingMovesForParent(parentId) {
+    if (!this.state.getVertex(parentId)) {
+      return;
+    }
+    const pendingMoves = this.pendingMovesWithMissingParent.get(parentId);
+    if (!pendingMoves) {
+      return;
+    }
+    this.pendingMovesWithMissingParent.delete(parentId);
+    for (const pendingOp of pendingMoves) {
+      this.applyMove(pendingOp);
+    }
+  }
+  tryToMove(op) {
+    let targetVertex = this.state.getVertex(op.targetId);
+    if (targetVertex) {
+      this.parentIdBeforeMove.set(op.id, targetVertex.parentId);
+    }
+    if (op.targetId === op.parentId) return;
+    if (op.parentId && this.isAncestor(op.parentId, op.targetId)) return;
+    this.state.moveVertex(op.targetId, op.parentId);
+    if (!targetVertex) {
+      const pendingProperties = this.pendingPropertiesWithMissingVertex.get(op.targetId) || [];
+      for (const prop of pendingProperties) {
+        this.setPropertyAndItsOpId(prop);
+      }
+    }
+  }
+  undoMove(op) {
+    const targetVertex = this.state.getVertex(op.targetId);
+    if (!targetVertex) {
+      console.error(`An attempt to undo move operation ${op.id.toString()} failed because the target vertex ${op.targetId} not found`);
+      return;
+    }
+    const prevParentId = this.parentIdBeforeMove.get(op.id);
+    if (prevParentId === void 0) {
+      return;
+    }
+    this.state.moveVertex(op.targetId, prevParentId);
+  }
+  setPropertyAndItsOpId(op) {
+    this.propertiesAndTheirOpIds.set(`${op.key}@${op.targetId}`, op.id);
+    this.state.setProperty(op.targetId, op.key, op.value);
+    this.reportOpAsApplied(op);
+  }
+  setTransientPropertyAndItsOpId(op) {
+    this.transientPropertiesAndTheirOpIds.set(`${op.key}@${op.targetId}`, op.id);
+    this.state.setTransientProperty(op.targetId, op.key, op.value);
+    this.reportOpAsApplied(op);
+  }
+  applyProperty(op) {
+    const targetVertex = this.state.getVertex(op.targetId);
+    if (!targetVertex) {
+      if (op.transient) {
+        return;
+      }
+      if (!this.pendingPropertiesWithMissingVertex.has(op.targetId)) {
+        this.pendingPropertiesWithMissingVertex.set(op.targetId, []);
+      }
+      this.pendingPropertiesWithMissingVertex.get(op.targetId).push(op);
+      return;
+    }
+    this.updateLamportClock(op);
+    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);
+      }
+      if (prevTransientOpId && op.id.isGreaterThan(prevTransientOpId)) {
+        this.transientPropertiesAndTheirOpIds.delete(`${op.key}@${op.targetId}`);
+        targetVertex.removeTransientProperty(op.key);
+      }
+    } else {
+      if (!prevTransientOpId || op.id.isGreaterThan(prevTransientOpId)) {
+        this.setTransientPropertyAndItsOpId(op);
+      }
+    }
+  }
+};
+_RepTree.TRASH_VERTEX_ID = "t";
+_RepTree.DEFAULT_MAX_DEPTH = 1e5;
+var RepTree = _RepTree;
+export {
+  OpId,
+  RepTree,
+  TreeState,
+  Vertex,
+  VertexState,
+  isMoveVertexOp,
+  isSetPropertyOp,
+  newMoveVertexOp,
+  newSetTransientVertexPropertyOp,
+  newSetVertexPropertyOp,
+  uuid
+};
+//# sourceMappingURL=index.js.map