@yorkie-js/sdk 0.7.3 → 0.7.4

package/dist/yorkie-js-sdk.d.ts

@@ -1882,6 +1882,16 @@ declare class CRDTTree extends CRDTElement implements GCParent {
     private indexTree;
     private nodeMapByID;
     constructor(root: CRDTTreeNode, createdAt: TimeTicket);
+    /**
+     * `rebuildMergeState` reconstructs the `mergedInto` cache on source
+     * parents from the persisted `mergedFrom` field on moved children.
+     * For snapshots written before `mergedAt` was added to the proto,
+     * it also falls back to the source's `removedAt` — an approximation
+     * that may be wrong if the source was later overwritten by a
+     * concurrent delete, but this is the best we can do without the
+     * persisted merge ticket.
+     */
+    private rebuildMergeState;
     /**
      * `create` creates a new instance of `CRDTTree`.
      */
@@ -1890,6 +1900,19 @@ declare class CRDTTree extends CRDTElement implements GCParent {
      * `findFloorNode` finds node of given id.
      */
     findFloorNode(id: CRDTTreeNodeID): CRDTTreeNode | undefined;
+    /**
+     * `advancePastUnknownSplitSiblings` follows the insNextID chain of the
+     * given node, advancing past element-type split siblings that the editing
+     * client did not know about (not in versionVector).
+     */
+    private advancePastUnknownSplitSiblings;
+    /**
+     * `hasUnknownSplitSibling` checks whether the given element node has a
+     * split sibling (via insNextID) whose creation the editor did not know
+     * about. Used to prevent styling via End tokens when a concurrent split
+     * extended the range into the split sibling.
+     */
+    private hasUnknownSplitSibling;
     /**
      * `registerNode` registers the given node to the tree.
      */
@@ -2079,6 +2102,29 @@ declare class CRDTTreeNode extends IndexTreeNode<CRDTTreeNode> implements GCPare
      * `insNextID` is the previous node id of this node after the node is split.
      */
     insNextID?: CRDTTreeNodeID;
+    /**
+     * `mergedFrom` records the source parent's ID when this node was moved
+     * by a concurrent merge. Persisted in the snapshot encoding as the
+     * witness of the merge relationship.
+     */
+    mergedFrom?: CRDTTreeNodeID;
+    /**
+     * `mergedAt` records the immutable ticket of the merge operation.
+     * Persisted alongside `mergedFrom` because the source parent's
+     * `removedAt` may be overwritten by later LWW tombstones and thus
+     * cannot serve as the merge-time causal boundary for splitElement's
+     * Fix 8 version-vector check.
+     */
+    mergedAt?: TimeTicket;
+    /**
+     * `mergedInto` is a runtime cache set on the source parent pointing
+     * at the merge target. Set locally during merge execution and rebuilt
+     * from `mergedFrom` on snapshot load. Used for the fast
+     * "is this tombstoned parent a merge source?" check in
+     * `FindTreeNodesWithSplitText`; the alternative (scanning
+     * `nodeMapByID` on every position resolution) would be too expensive.
+     */
+    mergedInto?: CRDTTreeNodeID;
     _value: string;
     constructor(id: CRDTTreeNodeID, type: string, opts?: string | Array<CRDTTreeNode>, attributes?: RHT, removedAt?: TimeTicket);
     /**
@@ -2124,7 +2170,7 @@ declare class CRDTTreeNode extends IndexTreeNode<CRDTTreeNode> implements GCPare
     /**
      * `split` splits the given offset of this node.
      */
-    split(tree: CRDTTree, offset: number, issueTimeTicket?: () => TimeTicket): [CRDTTreeNode | undefined, DataSize];
+    split(tree: CRDTTree, offset: number, issueTimeTicket?: () => TimeTicket, versionVector?: VersionVector): [CRDTTreeNode | undefined, DataSize];
     /**
      * `getCreatedAt` returns the creation time of this element.
      */
@@ -3493,10 +3539,17 @@ declare abstract class IndexTreeNode<T extends IndexTreeNode<T>> {
      * In this method, the child is physically removed from the tree.
      */
     removeChild(child: T): void;
+    /**
+     * `detachChild` removes the given child from this node's children list
+     * and updates both visibleSize and totalSize. Unlike `removeChild` which
+     * is used for GC purge of tombstoned nodes, `detachChild` is used for
+     * moving alive nodes between parents.
+     */
+    detachChild(child: T): void;
     /**
      * `splitElement` splits the given element at the given offset.
      */
-    splitElement(offset: number, issueTimeTicket: () => TimeTicket): [T | undefined, DataSize];
+    splitElement(offset: number, issueTimeTicket: () => TimeTicket, versionVector?: VersionVector): [T | undefined, DataSize];
     /**
      * `insertAfterInternal` inserts the given node after the given child.
      * This method does not update the size of the ancestors.
@@ -6473,6 +6526,22 @@ declare type TreeNode_3 = Message<"yorkie.v1.TreeNode"> & {
     attributes: {
         [key: string]: NodeAttr;
     };
+    /**
+     * merged_from is set when this node was moved to a new parent by a
+     * concurrent merge. It points to the source parent's ID.
+     *
+     * @generated from field: yorkie.v1.TreeNodeID merged_from = 9;
+     */
+    mergedFrom?: TreeNodeID;
+    /**
+     * merged_at records the immutable ticket of the merge operation.
+     * Stored alongside merged_from because the source parent's removed_at
+     * may be overwritten by later LWW tombstones and thus cannot serve as
+     * the merge-time causal boundary for SplitElement.
+     *
+     * @generated from field: yorkie.v1.TimeTicket merged_at = 10;
+     */
+    mergedAt?: TimeTicket_2;
 };
 
 /**