braid-text 0.2.19 → 0.2.20

package/index.js

@@ -580,31 +580,22 @@ braid_text.put = async (key, options) => {
     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
@@ -852,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([])
@@ -900,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.19",
+  "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)