braid-text 0.2.3 → 0.2.5

package/index.js

@@ -626,7 +626,8 @@ async function get_resource(key) {
         resource.need_defrag = false
 
         resource.actor_seqs = {}
-        let max_version = Math.max(...resource.doc.getLocalVersion()) ?? -1
+
+        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]
             resource.actor_seqs[v[0]] = Math.max(v[1], resource.actor_seqs[v[0]] ?? -1)
@@ -865,17 +866,28 @@ function dt_get(doc, version, agent = null) {
             ) {
                 for (; i < I; i++) {
                     let version = versions[i].join("-")
-                    if (!after_versions[version]) new_doc.mergeBytes(
+                    if (after_versions[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("-")]) {
+                            i++
+                            if (op_run.content?.[i - base_i]) content.push(op_run.content[i - base_i])
+                        }
+                    content = content.length ? content.join("") : null
+
+                    new_doc.mergeBytes(
                         dt_create_bytes(
                             version,
-                            parentss[i].map((x) => x.join("-")),
+                            parentss[og_i].map((x) => x.join("-")),
                             op_run.fwd ?
                                 (op_run.content ?
-                                    op_run.start + (i - base_i) :
+                                    op_run.start + (og_i - base_i) :
                                     op_run.start) :
                                 op_run.end - 1 - (i - base_i),
-                            op_run.content?.[i - base_i] != null ? 0 : 1,
-                            op_run.content?.[i - base_i]
+                            op_run.content ? 0 : i - og_i + 1,
+                            content
                         )
                     )
                 }
@@ -1073,7 +1085,7 @@ function dt_create_bytes(version, parents, pos, del, ins) {
     function write_string(byte_array, str) {
         let str_bytes = new TextEncoder().encode(str)
         write_varint(byte_array, str_bytes.length)
-        byte_array.push(...str_bytes)
+        for (let x of str_bytes) byte_array.push(x)
     }
 
     version = decode_version(version)
@@ -1101,11 +1113,11 @@ function dt_create_bytes(version, parents, pos, del, ins) {
 
     file_info.push(3)
     write_varint(file_info, agent_names.length)
-    file_info.push(...agent_names)
+    for (let x of agent_names) file_info.push(x)
 
     bytes.push(1)
     write_varint(bytes, file_info.length)
-    bytes.push(...file_info)
+    for (let x of file_info) bytes.push(x)
 
     let branch = []
 
@@ -1122,12 +1134,12 @@ function dt_create_bytes(version, parents, pos, del, ins) {
 
         branch.push(12)
         write_varint(branch, frontier.length)
-        branch.push(...frontier)
+        for (let x of frontier) branch.push(x)
     }
 
     bytes.push(10)
     write_varint(bytes, branch.length)
-    bytes.push(...branch)
+    for (let x of branch) bytes.push(x)
 
     let patches = []
 
@@ -1153,7 +1165,7 @@ function dt_create_bytes(version, parents, pos, del, ins) {
         let known_chunk = []
         write_varint(known_chunk, unicode_chars.length * 2 + 1)
         write_varint(inserted_content_bytes, known_chunk.length)
-        inserted_content_bytes.push(...known_chunk)
+        for (let x of known_chunk) inserted_content_bytes.push(x)
 
         patches.push(24)
         write_varint(patches, inserted_content_bytes.length)
@@ -1217,7 +1229,7 @@ function dt_create_bytes(version, parents, pos, del, ins) {
 
     patches.push(23)
     write_varint(patches, parents_bytes.length)
-    patches.push(...parents_bytes)
+    for (let x of parents_bytes) patches.push(x)
 
     // write in patches
     bytes.push(20)
@@ -1239,7 +1251,7 @@ function OpLog_remote_to_local(doc, frontier) {
 
     let local_version = []
 
-    let max_version = Math.max(-1, ...doc.getLocalVersion())
+    let max_version = doc.getLocalVersion().reduce((a, b) => Math.max(a, b), -1)
     for (let i = 0; i <= max_version; i++) {
         if (map[doc.localToRemoteVersion([i])[0].join("-")]) {
             local_version.push(i)
@@ -1568,7 +1580,7 @@ function decode_filename(encodedFilename) {
 function validate_version_array(x) {
     if (!Array.isArray(x)) throw new Error(`invalid version array: not an array`)
     x.sort()
-    for (xx of x) validate_actor_seq(xx)
+    for (var xx of x) validate_actor_seq(xx)
 }
 
 function validate_actor_seq(x) {
@@ -1720,6 +1732,8 @@ function apply_patch(obj, range, content) {
     }
 }
 
+braid_text.get_resource = get_resource
+
 braid_text.encode_filename = encode_filename
 braid_text.decode_filename = decode_filename
 

package/package.json

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

package/server-demo.js

@@ -37,12 +37,26 @@ var server = require("http").createServer(async (req, res) => {
     if (req.url.startsWith('/test.html')) {
         let parts = req.url.split(/[\?&=]/g)
 
-        if (parts[1] == 'check') {
+        if (parts[1] === 'check') {
             res.writeHead(200, { "Content-Type": "application/json", "Cache-Control": "no-cache" })
             return res.end(JSON.stringify({
                 checking: parts[2],
                 result: (await braid_text.get(parts[2])) != null
             }))
+        } else if (parts[1] === 'dt_create_bytes_big_name') {
+            try {
+                braid_text.dt_create_bytes('x'.repeat(1000000) + '-0', [], 0, 0, 'hi')
+                return res.end(JSON.stringify({ ok: true }))
+            } catch (e) {
+                return res.end(JSON.stringify({ ok: false, error: '' + e }))
+            }
+        } else if (parts[1] === 'dt_create_bytes_many_names') {
+            try {
+                braid_text.dt_create_bytes('hi-0', new Array(1000000).fill(0).map((x, i) => `x${i}-0`), 0, 0, 'hi')
+                return res.end(JSON.stringify({ ok: true }))
+            } catch (e) {
+                return res.end(JSON.stringify({ ok: false, error: '' + e }))
+            }
         }
 
         res.writeHead(200, { "Content-Type": "text/html", "Cache-Control": "no-cache" })

package/test.html

@@ -61,6 +61,50 @@ async function runTest(testName, testFunction, expectedResult) {
     }
 }
 
+runTest(
+    "test subscribing starting at a version using simpleton",
+    async () => {
+        let key = 'test-' + Math.random().toString(36).slice(2)
+
+        let r = await braid_fetch(`/${key}`, {
+            method: 'PUT',
+            version: ['hi-1'],
+            parents: [],
+            body: 'xx'
+        })
+        if (!r.ok) throw 'got: ' + r.statusCode
+
+        let r2 = await braid_fetch(`/${key}`, {
+            version: ['hi-0'],
+            subscribe: true
+        })
+        return await new Promise(async (done, fail) => {
+            r2.subscribe(update => {
+                done(JSON.stringify(update.parents))
+            }, fail)
+        })
+    },
+    JSON.stringify([ "hi-0" ])
+)
+
+runTest(
+    "test dt_create_bytes with big agent name",
+    async () => {
+        let x = await (await fetch(`/test.html?dt_create_bytes_big_name`)).json()
+        return JSON.stringify(x)
+    },
+    JSON.stringify({ok: true})
+)
+
+runTest(
+    "test dt_create_bytes with many agent names",
+    async () => {
+        let x = await (await fetch(`/test.html?dt_create_bytes_many_names`)).json()
+        return JSON.stringify(x)
+    },
+    JSON.stringify({ok: true})
+)
+
 runTest(
     "test deleting a resource",
     async () => {

package/test.js

@@ -16,6 +16,7 @@ async function main() {
     let best_seed = NaN
     let best_n = Infinity
     let base = Math.floor(Math.random() * 10000000)
+    let st = Date.now()
 
     let og_log = console.log
     console.log = () => {}
@@ -113,6 +114,7 @@ async function main() {
         }
     }
     og_log(`best_seed = ${best_seed}, best_n = ${best_n}`)
+    og_log(`time = ${Date.now() - st}`)
 }
 
 function make_random_edit(doc) {