braid-text 0.2.43 → 0.2.45

package/index.js

@@ -122,6 +122,7 @@ braid_text.serve = async (req, res, options = {}) => {
         } else {
             if (!res.hasHeader("editable")) res.setHeader("Editable", "true")
             res.setHeader("Merge-Type", merge_type)
+            res.setHeader("Current-Version", get_current_version())
             if (req.method == "HEAD") return my_end(200)
 
             let options = {
@@ -290,11 +291,6 @@ braid_text.get = async (key, options) => {
             options.my_last_sent_version = x.version
             resource.simpleton_clients.add(options)
         } else {
-            if (resource.need_defrag) {
-                if (braid_text.verbose) console.log(`doing defrag..`)
-                resource.need_defrag = false
-                resource.doc = defrag_dt(resource.doc)
-            }
 
             if (options.accept_encoding?.match(/updates\s*\((.*)\)/)?.[1].split(',').map(x=>x.trim()).includes('dt')) {
                 var bytes = resource.doc.toBytes()
@@ -525,8 +521,6 @@ braid_text.put = async (key, options) => {
     for (let b of bytes) resource.doc.mergeBytes(b)
     resource.val = resource.doc.get()
 
-    resource.need_defrag = true
-
     var post_commit_updates = []
 
     if (options.merge_type != "dt") {
@@ -673,17 +667,12 @@ async function get_resource(key) {
 
         resource.db_delta = change
 
-        resource.doc = defrag_dt(resource.doc)
-        resource.need_defrag = false
-
         resource.actor_seqs = {}
 
-        let max_version = resource.doc.getLocalVersion().reduce((a, b) => Math.max(a, b), -1)
-        for (let i = 0; i <= max_version; i++) {
-            let v = resource.doc.localToRemoteVersion([i])[0]
-            if (!resource.actor_seqs[v[0]]) resource.actor_seqs[v[0]] = new RangeSet()
-            resource.actor_seqs[v[0]].add_range(v[1], v[1])
-        }
+        dt_get_actor_seq_runs([...resource.doc.toBytes()], (actor, base, len) => {
+            if (!resource.actor_seqs[actor]) resource.actor_seqs[actor] = new RangeSet()
+            resource.actor_seqs[actor].add_range(base, base + len - 1)
+        })
 
         resource.val = resource.doc.get()
 
@@ -1068,16 +1057,19 @@ function dt_get(doc, version, agent = null, anti_version = null) {
 }
 
 function dt_get_patches(doc, version = null) {
+    if (version && v_eq(version,
+        doc.getRemoteVersion().map((x) => x.join("-")).sort())) {
+        // they want everything past the end, which is nothing
+        return []
+    }
+
     let bytes = doc.toBytes()
     doc = Doc.fromBytes(bytes)
 
     let [_agents, versions, parentss] = dt_parse([...bytes])
 
     let op_runs = []
-    if (version && v_eq(version,
-        doc.getRemoteVersion().map((x) => x.join("-")).sort())) {
-        // they want everything past the end, which is nothing
-    } else if (version?.length) {
+    if (version?.length) {
         let frontier = {}
         version.forEach((x) => frontier[x] = true)
         let local_version = []
@@ -1222,6 +1214,48 @@ function dt_parse(byte_array) {
     return [agents, versions, parentss]
 }
 
+function dt_get_actor_seq_runs(byte_array, cb) {
+    if (new TextDecoder().decode(new Uint8Array(byte_array.splice(0, 8))) !== "DMNDTYPS") throw new Error("dt parse error, expected DMNDTYPS")
+
+    if (byte_array.shift() != 0) throw new Error("dt parse error, expected version 0")
+
+    let agents = []
+
+    while (byte_array.length) {
+        let id = byte_array.shift()
+        let len = dt_read_varint(byte_array)
+        if (id == 1) {
+        } else if (id == 3) {
+            let goal = byte_array.length - len
+            while (byte_array.length > goal) {
+                agents.push(dt_read_string(byte_array))
+            }
+        } else if (id == 20) {
+        } else if (id == 21) {
+            let seqs = {}
+            let goal = byte_array.length - len
+            while (byte_array.length > goal) {
+                let part0 = dt_read_varint(byte_array)
+                let has_jump = part0 & 1
+                let agent_i = (part0 >> 1) - 1
+                let run_length = dt_read_varint(byte_array)
+                let jump = 0
+                if (has_jump) {
+                    let part2 = dt_read_varint(byte_array)
+                    jump = part2 >> 1
+                    if (part2 & 1) jump *= -1
+                }
+                let base = (seqs[agent_i] || 0) + jump
+
+                cb(agents[agent_i], base, run_length)
+                seqs[agent_i] = base + run_length
+            }
+        } else {
+            byte_array.splice(0, len)
+        }
+    }
+}
+
 function dt_get_local_version(bytes, version) {
     var looking_for = new Map()
     for (var event of version) {
@@ -1491,11 +1525,6 @@ function dt_create_bytes(version, parents, pos, del, ins) {
     return bytes
 }
 
-function defrag_dt(doc) {
-    let bytes = doc.toBytes()
-    doc.free()
-    return Doc.fromBytes(bytes, 'server')
-}
 
 function OpLog_remote_to_local(doc, frontier) {
     let map = Object.fromEntries(frontier.map((x) => [x, true]))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "braid-text",
-  "version": "0.2.43",
+  "version": "0.2.45",
   "description": "Library for collaborative text over http using braid.",
   "author": "Braid Working Group",
   "repository": "braid-org/braid-text",

package/test/test.html

@@ -96,6 +96,65 @@ async function runTest(testName, testFunction, expectedResult) {
     }
 }
 
+runTest(
+    "test loading a previously saved resource",
+    async () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+
+        var f1 = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            version: ['hi-2'],
+            parents: [],
+            body: 'abc'
+        })
+
+        var f1 = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `
+                delete braid_text.cache['/${key}']
+                res.end()
+            `
+        })
+
+        var r = await braid_fetch(`/${key}`)
+        return await r.text()
+    },
+    'abc'
+)
+
+runTest(
+    "test non-contigous ids",
+    async () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+
+        var r = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            version: ['hi-10'],
+            parents: [],
+            body: 'abc'
+        })
+
+        var r = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            version: ['hi-20'],
+            parents: ['hi-10'],
+            body: 'ABC'
+        })
+
+        var f1 = await braid_fetch(`/eval`, {
+            method: 'PUT',
+            body: `
+                delete braid_text.cache['/${key}']
+                res.end()
+            `
+        })
+
+        var r = await braid_fetch(`/${key}`)
+        return await r.text()
+    },
+    'ABC'
+)
+
 runTest(
     "test when PUT cache/buffer size fails",
     async () => {
@@ -1024,4 +1083,25 @@ runTest(
     '"yo-1", "hi-5", "hi-8"'
 )
 
+runTest(
+    "test that subscribe returns current-version header",
+    async () => {
+        var key = 'test-' + Math.random().toString(36).slice(2)
+
+        var r = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            version: ['hi-11'],
+            parents: [],
+            body: 'xyz'
+        })
+        if (!r.ok) throw 'got: ' + r.statusCode
+
+        var r = await braid_fetch(`/${key}`, {
+            subscribe: true
+        })
+        return r.headers.get('current-version')
+    },
+    '"hi-11"'
+)
+
 </script>