Apply updates from yorkie-js-sdk v0.4.28

Sources/API/Converter.swift

@@ -983,18 +983,18 @@ extension Converter {
 
         let nodes = pbTreeNodes.compactMap { fromTreeNode($0) }
 
-        let root = nodes[nodes.count - 1]
+        let rootIndex = nodes.count - 1
+        let root = nodes[rootIndex]
+
+        var depthTable: [Int32: CRDTTreeNode] = [
+            pbTreeNodes[rootIndex].depth: root
+        ]
 
-        for index in stride(from: nodes.count - 2, to: -1, by: -1) {
-            var parent: CRDTTreeNode?
-            for index2 in index + 1 ..< nodes.count {
-                if pbTreeNodes[index].depth - 1 == pbTreeNodes[index2].depth {
-                    parent = nodes[index2]
-                    break
-                }
-            }
-
-            try parent?.prepend(contentsOf: [nodes[index]])
+        for index in stride(from: rootIndex - 1, to: -1, by: -1) {
+            let node = nodes[index]
+            let parent = depthTable[pbTreeNodes[index].depth - 1]
+            try parent?.prepend(contentsOf: [node])
+            depthTable[pbTreeNodes[index].depth] = node
         }
 
         root.updateDescendantsSize()

Tests/Benchmark/DocumentBenchmarkTests.swift

@@ -18,7 +18,7 @@ import XCTest
 @testable import Yorkie
 
 final class DocumentBenchmarkTests: XCTestCase {
-    func benchmarkTree(_ size: Int) async {
+    func benchmarkTreeEdit(_ size: Int) async {
         let doc = Document(key: "test-doc")
 
         do {
@@ -130,27 +130,52 @@ final class DocumentBenchmarkTests: XCTestCase {
         }
     }
 
-    func testDocumentTree100() throws {
+    func benchmarkTreeConvert(_ size: Int) async {
+        let doc = Document(key: "test-doc")
+
+        do {
+            try await doc.update { root, _ in
+                var children: [JSONTreeTextNode] = []
+                for _ in 1 ... size {
+                    children.append(JSONTreeTextNode(value: "a"))
+                }
+
+                root.tree = JSONTree(initialRoot:
+                    JSONTreeElementNode(type: "doc",
+                                        children: [JSONTreeElementNode(type: "p", children: children)])
+                )
+            }
+
+            let root = try await(doc.getRoot().tree as? JSONTree)?.getIndexTree().root
+            let pbTreeNodes = Converter.toTreeNodes(root)
+            let convertedTreeNodes = try Converter.fromTreeNodes(pbTreeNodes)
+            XCTAssertNotNil(convertedTreeNodes, "Tree conversion failed")
+        } catch {
+            XCTFail("Benchmark failed with error: \(error)")
+        }
+    }
+
+    func testDocumentTreeEdit100() throws {
         self.measure {
             let exp = expectation(description: "measure")
 
             // Put the code you want to measure the time of here.
             Task { @MainActor in
-                await self.benchmarkTree(100)
+                await self.benchmarkTreeEdit(100)
                 exp.fulfill()
             }
 
             wait(for: [exp], timeout: 1)
         }
     }
 
-    func testDocumentTree1000() throws {
+    func testDocumentTreeEdit1000() throws {
         self.measure {
             let exp = expectation(description: "measure")
 
             // Put the code you want to measure the time of here.
             Task { @MainActor in
-                await self.benchmarkTree(1000)
+                await self.benchmarkTreeEdit(1000)
                 exp.fulfill()
             }
 
@@ -227,6 +252,45 @@ final class DocumentBenchmarkTests: XCTestCase {
             wait(for: [exp], timeout: 20)
         }
     }
+
+    func testDocumentTreeConvert10000() throws {
+        self.measure {
+            let exp = expectation(description: "measure")
+
+            Task { @MainActor in
+                await self.benchmarkTreeConvert(10000)
+                exp.fulfill()
+            }
+
+            wait(for: [exp], timeout: 20)
+        }
+    }
+
+    func testDocumentTreeConvert20000() throws {
+        self.measure {
+            let exp = expectation(description: "measure")
+
+            Task { @MainActor in
+                await self.benchmarkTreeConvert(20000)
+                exp.fulfill()
+            }
+
+            wait(for: [exp], timeout: 20)
+        }
+    }
+
+    func testDocumentTreeConvert30000() throws {
+        self.measure {
+            let exp = expectation(description: "measure")
+
+            Task { @MainActor in
+                await self.benchmarkTreeConvert(30000)
+                exp.fulfill()
+            }
+
+            wait(for: [exp], timeout: 20)
+        }
+    }
 }
 
 extension String {