@dtudury/streamo 0.1.0

package/public/streamo/utils/Recaller.js

@@ -0,0 +1,77 @@
+import { NestedSet } from './NestedSet.js'
+import { nextTick } from './nextTick.js'
+
+export class Recaller {
+  #deps = new NestedSet()
+  #names = new Map()
+  #stack = []
+  #pending = new Set()
+  #flushing = false
+  loopLimit = 10
+
+  constructor (name) {
+    if (!name) throw new Error('Recaller must be named')
+    this.name = name
+  }
+
+  /**
+   * Call f immediately while tracking any reportKeyAccess calls made during
+   * execution. Re-runs f whenever reportKeyMutation is called on a key that
+   * was accessed. Each re-run establishes a fresh set of tracked dependencies.
+   * @param {string} name
+   * @param {function} f
+   */
+  watch (name, f) {
+    if (!name || typeof name !== 'string') throw new Error('please name watches')
+    if (typeof f !== 'function') throw new Error(`can only watch functions (${name})`)
+    this.#disassociate(f)
+    this.#names.set(f, name)
+    this.#stack.unshift(f)
+    try { f(this) } catch (e) { console.error(e) }
+    this.#stack.shift()
+  }
+
+  unwatch (f) {
+    this.#disassociate(f)
+  }
+
+  reportKeyAccess (target, key) {
+    const f = this.#stack[0]
+    if (typeof f !== 'function') return
+    this.#deps.add(key, target, f)
+    this.#deps.add(f, target, key)
+  }
+
+  reportKeyMutation (target, key) {
+    const triggered = this.#deps.values(key, target)
+    if (!triggered.length) return
+    triggered.forEach(f => this.#pending.add(f))
+    if (this.#flushing) return
+    this.#flushing = true
+    nextTick(() => this.#flush())
+  }
+
+  #disassociate (f) {
+    this.#deps.delete(f)
+    this.#names.delete(f)
+  }
+
+  #flush () {
+    let loops = 0
+    while (this.#pending.size) {
+      if (loops >= this.loopLimit) {
+        console.error(`Recaller[${this.name}]: loop limit exceeded`)
+        break
+      }
+      const batch = [...this.#pending]
+      this.#pending = new Set()
+      batch.forEach(f => {
+        const name = this.#names.get(f) ?? f.name ?? '(unnamed)'
+        this.#disassociate(f)
+        this.watch(name, f)
+      })
+      loops++
+    }
+    this.#flushing = false
+  }
+}

package/public/streamo/utils/mockDOM.js

@@ -0,0 +1,113 @@
+/**
+ * Minimal DOM mock for testing mount() in Node.
+ *
+ * Implements only the subset of DOM APIs that hx.js mount() actually calls:
+ *   - createElement / createElementNS / createTextNode / createComment / createDocumentFragment
+ *   - appendChild, remove, before, nextSibling, childNodes
+ *   - setAttribute, getAttribute, removeAttribute, toggleAttribute
+ *   - textContent (read)
+ */
+
+class MockNode {
+  #children = []
+  #parent = null
+
+  constructor (nodeType) {
+    this.nodeType = nodeType
+  }
+
+  get childNodes () { return [...this.#children] }
+  get parentNode () { return this.#parent }
+
+  get textContent () {
+    return this.#children.map(c => c.textContent).join('')
+  }
+
+  get nextSibling () {
+    if (!this.#parent) return null
+    const sibs = this.#parent.#children
+    return sibs[sibs.indexOf(this) + 1] ?? null
+  }
+
+  appendChild (child) {
+    if (child.#parent) child.remove()
+    child.#parent = this
+    this.#children.push(child)
+    return child
+  }
+
+  remove () {
+    if (!this.#parent) return
+    this.#parent.#children = this.#parent.#children.filter(c => c !== this)
+    this.#parent = null
+  }
+
+  before (...nodes) {
+    if (!this.#parent) return
+    const i = this.#parent.#children.indexOf(this)
+    const toInsert = []
+    for (const n of nodes) {
+      if (n.nodeType === 11) { // DocumentFragment
+        const cs = [...n.#children]
+        n.#children = []
+        cs.forEach(c => { c.#parent = this.#parent })
+        toInsert.push(...cs)
+      } else {
+        if (n.#parent) n.remove()
+        n.#parent = this.#parent
+        toInsert.push(n)
+      }
+    }
+    this.#parent.#children.splice(i, 0, ...toInsert)
+  }
+}
+
+class MockElement extends MockNode {
+  #attrs = {}
+
+  constructor (tag) {
+    super(1)
+    this.tag = tag
+  }
+
+  setAttribute (name, val) { this.#attrs[name] = String(val) }
+  getAttribute (name) { return this.#attrs[name] ?? null }
+  removeAttribute (name) { delete this.#attrs[name] }
+  toggleAttribute (name, force) {
+    if (force) this.#attrs[name] = ''
+    else delete this.#attrs[name]
+  }
+  addEventListener () {}
+}
+
+class MockText extends MockNode {
+  constructor (value) {
+    super(3)
+    this.nodeValue = value
+  }
+
+  get textContent () { return this.nodeValue }
+}
+
+class MockComment extends MockNode {
+  constructor (value) {
+    super(8)
+    this.nodeValue = value
+  }
+
+  get textContent () { return '' }
+}
+
+class MockFragment extends MockNode {
+  constructor () { super(11) }
+}
+
+export const mockDocument = {
+  createElement: tag => new MockElement(tag),
+  createElementNS: (_ns, tag) => new MockElement(tag),
+  createTextNode: text => new MockText(text),
+  createComment: text => new MockComment(text),
+  createDocumentFragment: () => new MockFragment()
+}
+
+export { MockNode }

package/public/streamo/utils/nextTick.js

@@ -0,0 +1,22 @@
+const _next = typeof process !== 'undefined' ? process.nextTick : setTimeout
+
+let _pending = []
+let _scheduled = false
+
+const flush = () => {
+  for (let i = 0; i < 10; i++) {
+    _scheduled = false
+    const batch = _pending
+    _pending = []
+    batch.forEach(f => f())
+    if (!_pending.length) return
+  }
+  console.error('nextTick: flush loop exceeded 10 iterations')
+}
+
+export const nextTick = f => {
+  _pending.push(f)
+  if (_scheduled) return
+  _scheduled = true
+  _next(flush)
+}