braid-text 0.2.18 → 0.2.20

package/index.js

@@ -483,13 +483,16 @@ braid_text.put = async (key, options) => {
         let version = resource.doc.getRemoteVersion().map((x) => x.join("-")).sort()
 
         for (let client of resource.simpleton_clients) {
-            if (client.peer == peer) {
+            if (peer && client.peer === peer) {
                 client.my_last_seen_version = [og_v]
             }
 
             function set_timeout(time_override) {
                 if (client.my_timeout) clearTimeout(client.my_timeout)
                 client.my_timeout = setTimeout(() => {
+                    // if the doc has been freed, exit early
+                    if (resource.doc.__wbg_ptr === 0) return
+
                     let version = resource.doc.getRemoteVersion().map((x) => x.join("-")).sort()
                     let x = { version }
                     x.parents = client.my_last_seen_version
@@ -507,7 +510,7 @@ braid_text.put = async (key, options) => {
             }
 
             if (client.my_timeout) {
-                if (client.peer == peer) {
+                if (peer && client.peer === peer) {
                     if (!v_eq(client.my_last_sent_version, og_parents)) {
                         // note: we don't add to client.my_unused_version_count,
                         // because we're already in a timeout;
@@ -523,7 +526,7 @@ braid_text.put = async (key, options) => {
             }
 
             let x = { version }
-            if (client.peer == peer) {
+            if (peer && client.peer === peer) {
                 if (!v_eq(client.my_last_sent_version, og_parents)) {
                     client.my_unused_version_count = (client.my_unused_version_count ?? 0) + 1
                     set_timeout()
@@ -571,37 +574,28 @@ braid_text.put = async (key, options) => {
         patches: og_patches,
     }
     for (let client of resource.clients) {
-        if (client.peer != peer) client.subscribe(x)
+        if (!peer || client.peer !== peer) client.subscribe(x)
     }
 
     await resource.db_delta(resource.doc.getPatchSince(v_before))
 }
 
-// currently version must be an array with exactly one element, e.g. ["abc-1"]
 braid_text.revert = async (key, version) => {
     var resource = (typeof key == 'string') ? await get_resource(key) : key
 
-    var [actor, seq] = decode_version(version[0])
-
-    // get version without actor-seq,
-    // and update actor_seqs
-    var v = []
-    for (var [a, s] of Object.entries(resource.actor_seqs)) {
-        if (a !== actor) v.push(`${a}-${s}`)
-        else {
-            if (s < seq) return // nothing to do
-            else if (seq > 0) {
-                v.push(`${a}-${seq - 1}`)
-                resource.actor_seqs[actor] = seq - 1
-            } else delete resource.actor_seqs[actor]
-        }
-    }
-
     // revert dt
     var old_doc = resource.doc
-    resource.doc = dt_get(resource.doc, v)
+    resource.doc = dt_get(resource.doc, null, null, version)
     old_doc.free()
 
+    for (let v of version) {
+        var [actor, seq] = decode_version(v)
+        if ((resource.actor_seqs[actor] ?? -1) > seq - 1) {
+            if (seq > 0) resource.actor_seqs[actor] = seq - 1
+            else delete resource.actor_seqs[actor]
+        }
+    }
+
     resource.val = resource.doc.get()
 
     // save it
@@ -849,32 +843,47 @@ function dt_get_string(doc, version) {
     return s
 }
 
-function dt_get(doc, version, agent = null) {
+function dt_get(doc, version, agent = null, anti_version = null) {
     if (dt_get.last_doc) dt_get.last_doc.free()
 
     let bytes = doc.toBytes()
     dt_get.last_doc = doc = Doc.fromBytes(bytes, agent)
 
     let [_agents, versions, parentss] = dt_parse([...bytes])
-
-    let frontier = new Set(version)
-
-    let local_version = []
-    for (let i = 0; i < versions.length; i++) {
-        var v = versions[i].join("-")
-        if (frontier.has(v)) {
-            local_version.push(i)
-            frontier.delete(v)
+    if (anti_version) {
+        var include_versions = new Set()
+        var bad_versions = new Set(anti_version)
+
+        for (let i = 0; i < versions.length; i++) {
+            var v = versions[i].join("-")
+            var ps = parentss[i].map(x => x.join('-'))
+            if (bad_versions.has(v) || ps.some(x => bad_versions.has(x)))
+                bad_versions.add(v)
+            else
+                include_versions.add(v)
         }
-    }
-
-    if (frontier.size) throw new Error(`version not found: ${version}`)
+    } else {
+        var include_versions = new Set(version)
+        var looking_for = new Set(version)
+        var local_version = []
+
+        for (let i = versions.length - 1; i >= 0; i--) {
+            var v = versions[i].join("-")
+            var ps = parentss[i].map(x => x.join('-'))
+            if (looking_for.has(v)) {
+                local_version.push(i)
+                looking_for.delete(v)
+            }
+            if (include_versions.has(v))
+                ps.forEach(x => include_versions.add(x))
+        }
+        local_version.reverse()
 
-    dt_get.last_local_version = local_version = new Uint32Array(local_version)
+        // NOTE: currently used by braid-chrome in dt.js at the bottom
+        dt_get.last_local_version = new Uint32Array(local_version)
 
-    let after_versions = {}
-    let [_, after_versions_array, __] = dt_parse([...doc.getPatchSince(local_version)])
-    for (let v of after_versions_array) after_versions[v.join("-")] = true
+        if (looking_for.size) throw new Error(`version not found: ${version}`)
+    }
 
     let new_doc = new Doc(agent)
     let op_runs = doc.getOpsSince([])
@@ -897,12 +906,12 @@ function dt_get(doc, version, agent = null) {
             ) {
                 for (; i < I; i++) {
                     let version = versions[i].join("-")
-                    if (after_versions[version]) continue
+                    if (!include_versions.has(version)) continue
                     let og_i = i
                     let content = []
                     if (op_run.content?.[i - base_i]) content.push(op_run.content[i - base_i])
                     if (!!op_run.content === op_run.fwd)
-                        while (i + 1 < I && !after_versions[versions[i + 1].join("-")]) {
+                        while (i + 1 < I && include_versions.has(versions[i + 1].join("-"))) {
                             i++
                             if (op_run.content?.[i - base_i]) content.push(op_run.content[i - base_i])
                         }

package/package.json

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

package/test/test.js

@@ -4,10 +4,10 @@ let braid_text = require('../index.js')
 let {dt_get, dt_get_patches, dt_parse, dt_create_bytes} = braid_text
 
 process.on("unhandledRejection", (x) =>
-    console.log(`unhandledRejection: ${x.stack}`)
+    console.log(`unhandledRejection: ${x.stack ?? x}`)
 )
 process.on("uncaughtException", (x) =>
-    console.log(`uncaughtException: ${x.stack}`)
+    console.log(`uncaughtException: ${x.stack ?? x}`)
 )
 
 braid_text.db_folder = null
@@ -48,7 +48,7 @@ async function main() {
     for (let t = 0; t < 10000; t++) {
         let seed = base + t
     // for (let t = 0; t < 1; t++) {
-    //     let seed = 7375800
+        // let seed = 2746153
 
         og_log(`t = ${t}, seed = ${seed}, best_n = ${best_n} @ ${best_seed}`)
         Math.randomSeed(seed)
@@ -80,7 +80,6 @@ async function main() {
                 for (let x of dt_get_patches(doc)) {
                     var resource = await braid_text.get_resource(key)
                     var [actor, seq] = braid_text.decode_version(x.version)
-                    var pre_seq = resource.actor_seqs[actor]
                     var old_text = await braid_text.get(key)
 
                     console.log(`x = `, x)
@@ -99,7 +98,9 @@ async function main() {
                     await braid_text.put(key, y)
 
                     // test revert
-                    await braid_text.revert(key, [`${actor}-${(pre_seq ?? -1) + 1}`])
+                    var range = x.range.match(/\d+/g).map((x) => parseInt(x))
+                    var change_count = [...x.content].length + range[1] - range[0]
+                    await braid_text.revert(key, [`${actor}-${seq + 1 - change_count}`])
                     var new_text = await braid_text.get(key)
                     if (old_text !== new_text) throw new Error('revert failed!')
                     await braid_text.put(key, y)
@@ -127,6 +128,30 @@ async function main() {
             console.log(`doc = `, await braid_text.get('doc', {version: middle_v}))
             if (await braid_text.get('middle_doc') != (await braid_text.get('doc', {version: middle_v})).body) throw new Error('bad')
 
+            // test simplton
+            var first_time = true
+            await new Promise(async (done, fail) => {
+                await braid_text.get('middle_doc', {peer: 'sim', subscribe: async update => {
+                    if (first_time) {
+                        first_time = false
+                        if (update.body !== await braid_text.get('middle_doc')) fail(new Error('test 2'))
+
+                        var x = await braid_text.get('middle_doc', {})
+                        await braid_text.put('middle_doc', {peer: 'sim', version: ['sim-0'], parents: x.version, patches: [{content: 'A', range: '[0:0]'}]})
+                        await braid_text.put('middle_doc', {peer: 'other', merge_type: 'dt', version: ['other-0'], parents: [], patches: [{content: 'B', range: '[0:0]'}]})
+                        await braid_text.put('middle_doc', {peer: 'sim', version: ['sim-1'], parents: ['sim-0'], patches: [{content: 'b', range: '[0:0]'}]})
+                        await braid_text.put('middle_doc', {peer: 'sim', version: ['sim-2'], parents: ['sim-1'], patches: [{content: 'c', range: '[0:0]'}]})
+                        await braid_text.revert('middle_doc', ['sim-0'])
+                        await braid_text.revert('middle_doc', ['other-0'])
+
+                        done()
+                    }
+                }})
+            })
+
+            // test handler on dt
+            braid_text.get('middle_doc', {merge_type: 'dt', subscribe: async update => {}})
+
             // try getting updates from middle_doc to doc
             let o = {merge_type: 'dt', parents: middle_v, subscribe: update => {
                 braid_text.put('middle_doc', update)