@dtudury/streamo 1.0.0 → 2.0.0

package/public/streamo/Repo.test.js

@@ -1,82 +0,0 @@
-import { describe } from './utils/testing.js'
-import { Repo } from './Repo.js'
-
-describe(import.meta.url, ({ test }) => {
-  test('commit stores message, date, and a reference to the data', ({ assert }) => {
-    const repo = new Repo()
-    const working = repo.checkout()
-    working.set({ a: 1 })
-    const commitAddr = repo.commit(working, 'first commit')
-    const commit = repo.decode(commitAddr)
-    assert.equal(commit.message, 'first commit')
-    assert.ok(commit.date instanceof Date)
-    assert.equal(typeof commit.dataAddress, 'number')
-    assert.deepEqual(repo.decode(commit.dataAddress), { a: 1 })
-  })
-
-  test('checkout starts with last committed value', ({ assert }) => {
-    const repo = new Repo()
-    const working = repo.checkout()
-    working.set({ a: 1 })
-    repo.commit(working, 'first')
-    const working2 = repo.checkout()
-    assert.deepEqual(working2.get(), { a: 1 })
-  })
-
-  test('checkout of empty repo returns empty stream', ({ assert }) => {
-    const repo = new Repo()
-    const working = repo.checkout()
-    assert.equal(working.byteLength, 0)
-  })
-
-  test('working stream modifications do not affect the repository', ({ assert }) => {
-    const repo = new Repo()
-    const working = repo.checkout()
-    working.set({ v: 1 })
-    repo.commit(working, 'first')
-    const working2 = repo.checkout()
-    working2.set({ v: 99 })
-    // repo still has v:1 as last committed value
-    assert.deepEqual(repo.decode(repo.lastCommit.dataAddress), { v: 1 })
-  })
-
-  test('multiple commits produce a linked history via parent', ({ assert }) => {
-    const repo = new Repo()
-    const working = repo.checkout()
-    working.set({ v: 1 })
-    repo.commit(working, 'first')
-    working.set('v', 2)
-    repo.commit(working, 'second')
-    const c2 = repo.lastCommit
-    assert.equal(c2.message, 'second')
-    assert.deepEqual(repo.decode(c2.dataAddress), { v: 2 })
-    const c1 = repo.decode(c2.parent)
-    assert.equal(c1.message, 'first')
-    assert.deepEqual(repo.decode(c1.dataAddress), { v: 1 })
-  })
-
-  test('first commit has no parent', ({ assert }) => {
-    const repo = new Repo()
-    const working = repo.checkout()
-    working.set({ x: 1 })
-    repo.commit(working, 'root')
-    assert.equal(repo.lastCommit.parent, undefined)
-  })
-
-  test('unchanged data reuses the same address across commits', ({ assert }) => {
-    const repo = new Repo()
-    const working = repo.checkout()
-    working.set({ x: 42 })
-    repo.commit(working, 'first')
-    repo.commit(working, 'second')
-    const c2 = repo.lastCommit
-    const c1 = repo.decode(c2.parent)
-    assert.equal(c1.dataAddress, c2.dataAddress, 'same data reuses the same address')
-  })
-
-  test('throws when working stream is empty', ({ assert }) => {
-    const repo = new Repo()
-    const working = repo.checkout()
-    assert.throws(() => repo.commit(working, 'nothing here'))
-  })
-})

package/public/streamo/RepoRegistry.test.js

@@ -1,87 +0,0 @@
-import { describe } from './utils/testing.js'
-import { Streamo } from './Streamo.js'
-import { Repo } from './Repo.js'
-import { RepoRegistry } from './RepoRegistry.js'
-import { archiveSync } from './archiveSync.js'
-
-function archiveRegistry (dir) {
-  return new RepoRegistry(async key => {
-    const repo = new Repo()
-    await archiveSync(repo, dir, key)
-    return repo
-  })
-}
-
-describe(import.meta.url, ({ test }) => {
-  test('plain registry creates in-memory repositories with no factory', async ({ assert }) => {
-    const registry = new RepoRegistry()
-    const s = await registry.open('anykey')
-    assert.ok(s instanceof Repo)
-    s.set({ x: 1 })
-    assert.equal(s.get('x'), 1)
-  })
-
-  test('open creates a repository and returns the same instance on repeat calls', async ({ assert }) => {
-    const registry = new RepoRegistry()
-    const s1 = await registry.open('aabbcc')
-    const s2 = await registry.open('aabbcc')
-    assert.ok(s1 === s2, 'same instance returned')
-    assert.equal(registry.size, 1)
-  })
-
-  test('open creates independent repositories for different keys', async ({ assert }) => {
-    const registry = new RepoRegistry()
-    const s1 = await registry.open('key1')
-    const s2 = await registry.open('key2')
-    assert.ok(s1 !== s2)
-    assert.equal(registry.size, 2)
-    s1.set({ from: 'key1' })
-    s2.set({ from: 'key2' })
-    assert.equal(s1.get('from'), 'key1')
-    assert.equal(s2.get('from'), 'key2')
-  })
-
-  test('concurrent open() calls return the same instance', async ({ assert }) => {
-    let created = 0
-    const registry = new RepoRegistry(async () => {
-      created++
-      await new Promise(r => setTimeout(r, 10))
-      return new Repo()
-    })
-    const [s1, s2, s3] = await Promise.all([
-      registry.open('k'),
-      registry.open('k'),
-      registry.open('k')
-    ])
-    assert.equal(created, 1, 'factory called only once')
-    assert.ok(s1 === s2 && s2 === s3, 'all calls return same instance')
-  })
-
-  test('get returns undefined for unopened or still-opening keys', async ({ assert }) => {
-    const registry = new RepoRegistry()
-    assert.equal(registry.get('nope'), undefined)
-    await registry.open('exists')
-    assert.ok(registry.get('exists') instanceof Streamo)
-  })
-
-  test('iterates over fully-opened repositories only', async ({ assert }) => {
-    const registry = new RepoRegistry()
-    await registry.open('a')
-    await registry.open('b')
-    const entries = [...registry]
-    assert.equal(entries.length, 2)
-    assert.deepEqual(entries.map(([k]) => k).sort(), ['a', 'b'])
-  })
-
-  test('archive factory persists and reloads repository data', async ({ assert }) => {
-    const dir = '/tmp/repository-registry-persist-test-' + Date.now()
-    const r1 = archiveRegistry(dir)
-    const s1 = await r1.open('testkey')
-    s1.set({ saved: true })
-    await new Promise(r => setTimeout(r, 50))
-
-    const r2 = archiveRegistry(dir)
-    const s2 = await r2.open('testkey')
-    assert.equal(s2.get('saved'), true, 'data survived registry reload')
-  })
-})

package/public/streamo/Streamo.test.js

@@ -1,205 +0,0 @@
-import { describe } from './utils/testing.js'
-import { Streamo, ConflictError } from './Streamo.js'
-import { Signer } from './Signer.js'
-import { Signature } from './Signature.js'
-
-describe(import.meta.url, ({ test }) => {
-  test('encodes and decodes primitive values', ({ assert }) => {
-    const s = new Streamo()
-    const values = [
-      undefined, null, false, true,
-      0, 1, 127,
-      128, -1, 3.14, Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY,
-      new Uint8Array([1, 2, 3]),
-      new Uint8Array([4, 5, 6, 7]),
-      new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
-      'hello',
-      'a longer string that definitely does not fit in four bytes',
-      new Date('1969-07-21T22:56:15Z'),
-      { a: 1, b: 2, c: 3 },
-      { x: 'hello' },
-      {},
-      [1, 2, 3],
-      [],
-      ['a', 'b'],
-      new Signature(0, new Uint8Array(64))
-    ]
-    for (const value of values) {
-      const code = s.encodeVariable(value)
-      const decoded = s.decode(code)
-      assert.deepEqual(decoded, value, `round-trips ${Object.prototype.toString.call(value)}`)
-    }
-  })
-
-  test('negative addresses for single-byte primitives', ({ assert }) => {
-    const s = new Streamo()
-    for (const v of [undefined, null, false, true, 0, 1, 127]) {
-      const code = s.encode(v)
-      assert.equal(code.length, 1, `${String(v)} encodes to 1 byte`)
-      const addr = -(code[0] + 1)
-      assert.ok(addr < 0, `${String(v)} has a negative address`)
-      assert.deepEqual(s.decode(addr), v, `negative address resolves back to ${String(v)}`)
-    }
-  })
-
-  test('deduplication: same value always gets the same address', ({ assert }) => {
-    const s = new Streamo()
-    const a1 = s.append(s.encode(42))
-    s.append(s.encode({ x: 42 }))
-    const code42 = s.encode(42)
-    assert.equal(s.addressOf(code42), a1, 'second encode of 42 reuses the existing address')
-  })
-
-  test('reactive get/set/watch', async ({ assert }) => {
-    const s = new Streamo()
-    let callCount = 0
-    let lastValue
-
-    s.watch('test', () => {
-      lastValue = s.get('greeting')
-      callCount++
-    })
-    assert.equal(callCount, 1, 'watch runs immediately')
-    assert.equal(lastValue, undefined, 'no value yet')
-
-    s.set({ greeting: 'hello' })
-    await new Promise(resolve => setTimeout(resolve, 20))
-    assert.equal(callCount, 2, 'watch re-ran after set')
-    assert.equal(lastValue, 'hello', 'updated value seen')
-
-    s.set('greeting', 'world')
-    await new Promise(resolve => setTimeout(resolve, 20))
-    assert.equal(callCount, 3, 'watch re-ran after path set')
-    assert.equal(lastValue, 'world', 'path update seen')
-  })
-
-  test('asRefs returns addresses for object values and names', ({ assert }) => {
-    const s = new Streamo()
-    const code = s.encode({ a: 1 })
-
-    // asRefs=true: values become addresses, names stay as strings
-    const withTrue = s.decode(code, true)
-    assert.deepEqual(Object.keys(withTrue), ['a'])
-    assert.equal(typeof withTrue.a, 'number', 'value is an address')
-    assert.equal(s.decode(withTrue.a), 1, 'address decodes to original value')
-
-    // asRefs=[true, false]: same — value is address, name is string
-    const withValueRef = s.decode(code, [true, false])
-    assert.equal(typeof withValueRef.a, 'number')
-    assert.equal(s.decode(withValueRef.a), 1)
-
-    // asRefs=[false, true]: value decoded, name is address
-    const withNameRef = s.decode(code, [false, true])
-    assert.deepEqual(Object.values(withNameRef), [1])
-    const nameAddr = Number(Object.keys(withNameRef)[0])
-    assert.equal(s.decode(nameAddr), 'a', 'key address decodes to the name string')
-  })
-
-  test('asRefs: object returns name/address map', ({ assert }) => {
-    const s = new Streamo()
-    s.set({ x: 1, y: 2 })
-    const refs = s.asRefs(s.byteLength - 1)
-    assert.deepEqual(Object.keys(refs), ['x', 'y'])
-    assert.equal(typeof refs.x, 'number')
-    assert.equal(typeof refs.y, 'number')
-    assert.equal(s.decode(refs.x), 1)
-    assert.equal(s.decode(refs.y), 2)
-  })
-
-  test('asRefs: array returns element addresses', ({ assert }) => {
-    const s = new Streamo()
-    s.set(['a', 'b', 'c'])
-    const refs = s.asRefs(s.byteLength - 1)
-    assert.ok(Array.isArray(refs))
-    assert.equal(refs.length, 3)
-    refs.forEach(addr => assert.equal(typeof addr, 'number'))
-    assert.equal(s.decode(refs[0]), 'a')
-    assert.equal(s.decode(refs[1]), 'b')
-    assert.equal(s.decode(refs[2]), 'c')
-  })
-
-  test('asRefs: non-object returns the address itself', ({ assert }) => {
-    const s = new Streamo()
-    s.set('hello')
-    const address = s.byteLength - 1
-    assert.equal(s.asRefs(address), address)
-  })
-
-  test('encode(asRefs(addr), true) round-trips an object', ({ assert }) => {
-    const s = new Streamo()
-    s.set({ a: 1, b: 'hello' })
-    const addr = s.byteLength - 1
-    const refs = s.asRefs(addr)
-    const code = s.encode(refs, true)
-    assert.deepEqual(s.decode(code), { a: 1, b: 'hello' })
-  })
-
-  test('encode(asRefs(addr), true) round-trips an array', ({ assert }) => {
-    const s = new Streamo()
-    s.set([10, 20, 30])
-    const addr = s.byteLength - 1
-    const refs = s.asRefs(addr)
-    const code = s.encode(refs, true)
-    assert.deepEqual(s.decode(code), [10, 20, 30])
-  })
-
-  test('encode(asRefs(addr), true) round-trips a primitive', ({ assert }) => {
-    const s = new Streamo()
-    s.set('hello')
-    const addr = s.byteLength - 1
-    const refs = s.asRefs(addr)  // returns addr itself for non-objects
-    const code = s.encode(refs, true)  // resolves addr → string code
-    assert.equal(s.decode(code), 'hello')
-  })
-
-  test('sign and verify', async ({ assert }) => {
-    const s = new Streamo()
-    s.set({ hello: 'world' })
-    s.set('hello', 'signed')
-
-    const signer = new Signer('alice', 'secret')
-    const name = 'my-streamo'
-    const keys = await signer.keysFor(name)
-    const sig = await s.sign(signer, name)
-
-    assert.ok(sig instanceof Signature)
-    assert.ok(await s.verify(sig, keys.publicKey), 'signature verifies with correct key')
-
-    const other = new Signer('bob', 'different')
-    const otherKeys = await other.keysFor(name)
-    assert.ok(!(await s.verify(sig, otherKeys.publicKey)), 'wrong key does not verify')
-  })
-
-  test('conditionalSet rejects stale edits and accepts fresh ones', ({ assert }) => {
-    const s = new Streamo()
-    s.set({ x: 1 })
-    const tip = s.byteLength
-
-    // A concurrent write advances the streamo past tip
-    s.set({ x: 2 })
-
-    // Stale edit is rejected
-    let caught
-    try { s.conditionalSet(tip, { x: 3 }) } catch (e) { caught = e }
-    assert.ok(caught instanceof ConflictError, 'throws ConflictError')
-    assert.equal(caught.expectedTip, tip)
-    assert.equal(caught.actualTip, s.byteLength)
-    assert.equal(s.get('x'), 2, 'streamo unchanged after rejection')
-
-    // Fresh edit at current tip succeeds
-    const freshTip = s.byteLength
-    s.conditionalSet(freshTip, { x: 3 })
-    assert.equal(s.get('x'), 3, 'fresh conditional set applied')
-  })
-
-  test('clone snapshots state at a given address', ({ assert }) => {
-    const s = new Streamo()
-    s.set({ v: 1 })
-    const addr1 = s.byteLength - 1
-    s.set({ v: 2 })
-
-    const snap = s.clone(addr1)
-    assert.equal(snap.get('v'), 1, 'clone reflects state at snapshot address')
-    assert.equal(s.get('v'), 2, 'original still reflects latest state')
-  })
-})

package/public/streamo/h.mount.test.js

@@ -1,67 +0,0 @@
-import { describe } from './utils/testing.js'
-import { h } from './h.js'
-import { mount } from './mount.js'
-import { Streamo } from './Streamo.js'
-
-const IS_NODE = typeof process !== 'undefined' && process.versions?.node != null
-
-if (IS_NODE) {
-  const { mockDocument, MockNode } = await import('./utils/mockDOM.js')
-  globalThis.document = mockDocument
-  globalThis.Node = MockNode
-}
-
-describe(import.meta.url, ({ test }) => {
-  test('mounts a static element with text', ({ assert }) => {
-    const container = document.createElement('div')
-    mount(h`<span>hello</span>`, container)
-    const span = container.childNodes[0]
-    assert.equal(span.textContent, 'hello')
-  })
-
-  test('reactive text slot updates after stream.set', async ({ assert }) => {
-    const stream = new Streamo()
-    stream.set({ greeting: 'hello' })
-    const container = document.createElement('div')
-    mount(h`<span>${() => stream.get('greeting')}</span>`, container, stream.recaller)
-
-    const span = container.childNodes[0]
-    assert.equal(span.textContent, 'hello', 'initial render')
-
-    stream.set('greeting', 'world')
-    await new Promise(resolve => setTimeout(resolve, 20))
-    assert.equal(span.textContent, 'world', 'updated after set')
-  })
-
-  test('reactive attribute updates after stream.set', async ({ assert }) => {
-    const stream = new Streamo()
-    stream.set({ cls: 'active' })
-    const container = document.createElement('div')
-    mount(h`<div class=${() => stream.get('cls')}></div>`, container, stream.recaller)
-
-    const div = container.childNodes[0]
-    assert.equal(div.getAttribute('class'), 'active', 'initial attribute')
-
-    stream.set('cls', 'inactive')
-    await new Promise(resolve => setTimeout(resolve, 20))
-    assert.equal(div.getAttribute('class'), 'inactive', 'updated attribute')
-  })
-
-  test('unrelated stream.set does not re-render slot', async ({ assert }) => {
-    const stream = new Streamo()
-    stream.set({ a: 'unchanged', b: 'watched' })
-    let renderCount = 0
-    const container = document.createElement('div')
-    mount(h`<span>${() => { renderCount++; return stream.get('b') }}</span>`, container, stream.recaller)
-
-    assert.equal(renderCount, 1, 'initial render')
-
-    stream.set('a', 'changed')
-    await new Promise(resolve => setTimeout(resolve, 20))
-    assert.equal(renderCount, 1, 'no re-render when unrelated key changes')
-
-    stream.set('b', 'also changed')
-    await new Promise(resolve => setTimeout(resolve, 20))
-    assert.equal(renderCount, 2, 're-renders when watched key changes')
-  })
-})

package/public/streamo/h.test.js

@@ -1,121 +0,0 @@
-import { describe } from './utils/testing.js'
-import { h, HElement, HText } from './h.js'
-
-describe(import.meta.url, ({ test }) => {
-  test('plain element', ({ assert }) => {
-    const [div] = h`<div></div>`
-    assert.ok(div instanceof HElement)
-    assert.equal(div.tag, 'div')
-    assert.deepEqual(div.attrs, [])
-    assert.deepEqual(div.children, [])
-  })
-
-  test('void element produces no children', ({ assert }) => {
-    const [br] = h`<br>`
-    assert.ok(br instanceof HElement)
-    assert.equal(br.tag, 'br')
-    assert.deepEqual(br.children, [])
-  })
-
-  test('static attributes', ({ assert }) => {
-    const [el] = h`<input type="text" placeholder='name'>`
-    assert.equal(el.attrs[0].name, 'type')
-    assert.equal(el.attrs[0].value, 'text')
-    assert.equal(el.attrs[1].name, 'placeholder')
-    assert.equal(el.attrs[1].value, 'name')
-  })
-
-  test('boolean attribute (no value)', ({ assert }) => {
-    const [el] = h`<button disabled></button>`
-    assert.equal(el.attrs[0].name, 'disabled')
-    assert.equal(el.attrs[0].value, undefined)
-  })
-
-  test('dynamic attribute value', ({ assert }) => {
-    const cls = 'active'
-    const [el] = h`<div class=${cls}></div>`
-    assert.equal(el.attrs[0].name, 'class')
-    assert.equal(el.attrs[0].value, 'active')
-  })
-
-  test('function slot as attribute value', ({ assert }) => {
-    const fn = () => 'red'
-    const [el] = h`<div style=${'color:' + fn()}></div>`
-    assert.equal(el.attrs[0].value, 'color:red')
-  })
-
-  test('text node child', ({ assert }) => {
-    const [el] = h`<p>hello world</p>`
-    assert.equal(el.children.length, 1)
-    assert.ok(el.children[0] instanceof HText)
-    assert.equal(el.children[0].value, 'hello world')
-  })
-
-  test('dynamic child slot', ({ assert }) => {
-    const val = 42
-    const [el] = h`<span>${val}</span>`
-    assert.equal(el.children[0], 42)
-  })
-
-  test('function child slot preserved as function', ({ assert }) => {
-    const fn = () => 'dynamic'
-    const [el] = h`<span>${fn}</span>`
-    assert.equal(typeof el.children[0], 'function')
-    assert.equal(el.children[0](), 'dynamic')
-  })
-
-  test('nested elements', ({ assert }) => {
-    const [ul] = h`<ul><li>a</li><li>b</li></ul>`
-    assert.equal(ul.tag, 'ul')
-    assert.equal(ul.children.length, 2)
-    assert.equal(ul.children[0].tag, 'li')
-    assert.equal(ul.children[1].tag, 'li')
-  })
-
-  test('mixed text and element children', ({ assert }) => {
-    const [p] = h`<p>hello <strong>world</strong></p>`
-    assert.ok(p.children[0] instanceof HText)
-    assert.equal(p.children[0].value, 'hello ')
-    assert.equal(p.children[1].tag, 'strong')
-  })
-
-  test('HTML entity decoding', ({ assert }) => {
-    const [el] = h`<p>a &amp; b &lt; c &gt; d</p>`
-    assert.equal(el.children[0].value, 'a & b < c > d')
-  })
-
-  test('multiple root nodes', ({ assert }) => {
-    const nodes = h`<li>a</li><li>b</li>`
-    assert.equal(nodes.length, 2)
-    assert.equal(nodes[0].tag, 'li')
-    assert.equal(nodes[1].tag, 'li')
-  })
-
-  test('self-closing syntax', ({ assert }) => {
-    const [el] = h`<MyComponent />`
-    assert.ok(el instanceof HElement)
-    assert.equal(el.tag, 'MyComponent')
-    assert.deepEqual(el.children, [])
-  })
-
-  test('mixed static/dynamic attribute value parts', ({ assert }) => {
-    // A plain string slot gets joined into the surrounding text
-    const color = 'red'
-    const [el1] = h`<div style="color: ${color}; font-size: 12px"></div>`
-    assert.equal(el1.attrs[0].value, 'color: red; font-size: 12px')
-
-    // A function slot stays as an array so mount() can wire up reactivity
-    const colorFn = () => 'blue'
-    const [el2] = h`<div style="color: ${colorFn}; font-size: 12px"></div>`
-    assert.ok(Array.isArray(el2.attrs[0].value))
-    assert.equal(el2.attrs[0].value[0], 'color: ')
-    assert.equal(typeof el2.attrs[0].value[1], 'function')
-    assert.equal(el2.attrs[0].value[2], '; font-size: 12px')
-  })
-
-  test('spread attribute object', ({ assert }) => {
-    const extra = { id: 'foo', 'data-x': '1' }
-    const [el] = h`<div ${extra}></div>`
-    assert.deepEqual(el.attrs[0], extra)
-  })
-})