@nxtedition/deepstream.io-client-js 32.0.19 → 32.0.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/deepstream.io-client-js",
-  "version": "32.0.19",
+  "version": "32.0.21",
   "description": "the javascript client for deepstream.io",
   "homepage": "http://deepstream.io",
   "type": "module",

package/src/client.d.ts

@@ -3,7 +3,7 @@ import type { Paths, Get } from './record/record.js'
 import type RecordHandler from './record/record-handler.js'
 import type { RecordStats, ProvideOptions, SyncOptions } from './record/record-handler.js'
 import type EventHandler from './event/event-handler.js'
-import type { EventStats } from './event/event-handler.js'
+import type { EventStats, EventProvideOptions } from './event/event-handler.js'
 import type RpcHandler from './rpc/rpc-handler.js'
 import type { RpcStats, RpcMethodDef } from './rpc/rpc-handler.js'
 
@@ -30,6 +30,7 @@ export type {
   RpcHandler,
   RpcMethodDef,
   ProvideOptions,
+  EventProvideOptions,
   SyncOptions,
   Paths,
   Get,

package/src/event/event-handler.d.ts

@@ -4,7 +4,7 @@ export default class EventHandler {
   connected: boolean
   stats: EventStats
   subscribe: (name: string, callback: (data: unknown) => void) => void
-  unsubscribe: (name: string, callback: (data: unknown) => void) => void
+  unsubscribe: (name: string, callback?: (data: unknown) => void) => void
   on: (name: string, callback: (data: unknown) => void) => this
   once: (name: string, callback: (data: unknown) => void) => this
   off: (name: string, callback: (data: unknown) => void) => this
@@ -13,10 +13,15 @@ export default class EventHandler {
   provide: (
     pattern: string,
     callback: (name: string) => void,
-    options: unknown,
+    options: EventProvideOptions,
   ) => (() => void) | void
 }
 
+export interface EventProvideOptions {
+  mode?: 'unicast' | (string & {})
+  stringify?: ((input: unknown) => string) | null
+}
+
 export interface EventStats {
   emitted: number
   listeners: number

package/src/event/event-handler.js

@@ -1,7 +1,7 @@
 import * as C from '../constants/constants.js'
 import * as messageBuilder from '../message/message-builder.js'
 import * as messageParser from '../message/message-parser.js'
-import MulticastListener from '../utils/multicast-listener.js'
+import LegacyListener from '../utils/legacy-listener.js'
 import UnicastListener from '../utils/unicast-listener.js'
 import EventEmitter from 'component-emitter2'
 import * as rxjs from 'rxjs'
@@ -71,12 +71,12 @@ EventHandler.prototype.unsubscribe = function (name, callback) {
   }
 }
 
-EventHandler.on = function (name, callback) {
+EventHandler.prototype.on = function (name, callback) {
   this.subscribe(name, callback)
   return this
 }
 
-EventHandler.once = function (name, callback) {
+EventHandler.prototype.once = function (name, callback) {
   const fn = (...args) => {
     this.unsubscribe(name, fn)
     callback(...args)
@@ -85,7 +85,7 @@ EventHandler.once = function (name, callback) {
   return this
 }
 
-EventHandler.off = function (name, callback) {
+EventHandler.prototype.off = function (name, callback) {
   this.unsubscribe(name, callback)
   return this
 }
@@ -126,7 +126,7 @@ EventHandler.prototype.provide = function (pattern, callback, options) {
   const listener =
     options.mode?.toLowerCase() === 'unicast'
       ? new UnicastListener(C.TOPIC.EVENT, pattern, callback, this, options)
-      : new MulticastListener(C.TOPIC.EVENT, pattern, callback, this, options)
+      : new LegacyListener(C.TOPIC.EVENT, pattern, callback, this, options)
 
   this._listeners.set(pattern, listener)
   return () => {

package/src/record/record-handler.d.ts

@@ -42,6 +42,37 @@ export default class RecordHandler<Records = Record<string, unknown>> {
     optionsOrRecursive?: ProvideOptions | boolean,
   ) => Disposer | void
 
+  put: (
+    name: string,
+    version: string,
+    data: Record<string, unknown> | null,
+    parent?: string,
+  ) => void
+
+  getAsync: {
+    <Name extends string>(
+      name: Name,
+      options: ObserveOptions,
+    ):
+      | { value: Lookup<Records, Name>; async: false }
+      | { value: Promise<Lookup<Records, Name>>; async: true }
+
+    <Name extends string, Path extends string | string[]>(
+      name: Name,
+      path: Path,
+      options?: ObserveOptions,
+    ):
+      | { value: Get<Lookup<Records, Name>, Path>; async: false }
+      | { value: Promise<Get<Lookup<Records, Name>, Path>>; async: true }
+
+    <Name extends string>(
+      name: Name,
+      state?: number,
+    ):
+      | { value: Lookup<Records, Name>; async: false }
+      | { value: Promise<Lookup<Records, Name>>; async: true }
+  }
+
   sync: (options?: SyncOptions) => Promise<void>
 
   set: {
@@ -287,12 +318,13 @@ export interface RecordStats {
   pruning: number
   patching: number
   subscriptions: number
+  listeners: number
 }
 
 export interface ProvideOptions {
   recursive?: boolean
   stringify?: ((input: unknown) => string) | null
-  mode: undefined | null | 'unicast'
+  mode?: null | 'unicast' | (string & {})
 }
 
 export interface SyncOptions {

package/src/record/record-handler.js

@@ -1,5 +1,5 @@
 import Record from './record.js'
-import MulticastListener from '../utils/multicast-listener.js'
+import LegacyListener from '../utils/legacy-listener.js'
 import UnicastListener from '../utils/unicast-listener.js'
 import * as C from '../constants/constants.js'
 import * as rxjs from 'rxjs'
@@ -35,7 +35,7 @@ const GET2_DEFAULTS = {
 
 function onSync(subscription) {
   subscription.synced = true
-  onUpdate(subscription.record, subscription)
+  onUpdate(null, subscription)
 }
 
 function onUpdate(record, subscription) {
@@ -84,9 +84,18 @@ function onTimeout(subscription) {
 
   subscription.subscriber.error(
     Object.assign(
-      new Error(`timeout state: ${subscription.record.name} [${current}<${expected}]`),
+      new Error(
+        !subscription.synced
+          ? `timeout sync: ${subscription.record.name}`
+          : `timeout state: ${subscription.record.name} [${current}<${expected}]`,
+      ),
       {
         code: 'ETIMEDOUT',
+        timeout: subscription.timeoutValue,
+        expected,
+        current,
+        synced: subscription.synced,
+        name: subscription.record.name,
       },
     ),
   )
@@ -119,7 +128,7 @@ class RecordHandler {
     }
 
     this._syncQueue = []
-    this._syncMap = {}
+    this._syncMap = new Map()
 
     this.set = this.set.bind(this)
     this.get = this.get.bind(this)
@@ -219,13 +228,18 @@ class RecordHandler {
    * @returns {Record}
    */
   getRecord(name) {
-    invariant(
-      typeof name === 'string' &&
-        name.length > 0 &&
-        name !== '[object Object]' &&
-        name.length <= 4096,
-      `invalid name ${name}`,
-    )
+    if (typeof name !== 'string' || name.length === 0) {
+      throw new Error('invalid argument: name')
+    }
+
+    if (name.startsWith('null') || name.startsWith('undefined') || name === '[object Object]') {
+      this._client._$onError(
+        C.TOPIC.RECORD,
+        C.EVENT.USER_ERROR,
+        'name should not start with null or undefined',
+        name,
+      )
+    }
 
     let record = this._records.get(name)
 
@@ -261,7 +275,7 @@ class RecordHandler {
     const listener =
       options.mode?.toLowerCase() === 'unicast'
         ? new UnicastListener(C.TOPIC.RECORD, pattern, callback, this, options)
-        : new MulticastListener(C.TOPIC.RECORD, pattern, callback, this, options)
+        : new LegacyListener(C.TOPIC.RECORD, pattern, callback, this, options)
 
     this._stats.listeners += 1
     this._listeners.set(pattern, listener)
@@ -282,7 +296,7 @@ class RecordHandler {
     // TODO (perf): Slow implementation...
 
     const signal = opts?.signal
-    const timeout = opts?.timeout
+    const timeout = opts?.timeout ?? 10 * 60e3
 
     let disposers
     try {
@@ -298,18 +312,17 @@ class RecordHandler {
       signalPromise?.catch(noop)
 
       if (this._patching.size) {
-        let promises
+        const promises = []
 
         {
           const patchingPromises = []
           for (const callbacks of this._patching.values()) {
             patchingPromises.push(new Promise((resolve) => callbacks.push(resolve)))
           }
-          promises ??= []
           promises.push(Promise.all(patchingPromises))
         }
 
-        if (timeout) {
+        if (timeout && promises.length) {
           promises.push(
             new Promise((resolve) => {
               const patchingTimeout = timers.setTimeout(() => {
@@ -326,30 +339,28 @@ class RecordHandler {
           )
         }
 
-        if (signalPromise) {
-          promises ??= []
+        if (signalPromise && promises.length) {
           promises.push(signalPromise)
         }
 
-        if (promises) {
+        if (promises.length) {
           await Promise.race(promises)
+          signal?.throwIfAborted()
         }
       }
 
       if (this._updating.size) {
-        let promises
+        const promises = []
 
         {
           const updatingPromises = []
           for (const callbacks of this._updating.values()) {
             updatingPromises.push(new Promise((resolve) => callbacks.push(resolve)))
           }
-          promises ??= []
           promises.push(Promise.all(updatingPromises))
         }
 
-        if (timeout) {
-          promises ??= []
+        if (timeout && promises.length) {
           promises.push(
             new Promise((resolve) => {
               const updatingTimeout = timers.setTimeout(() => {
@@ -366,18 +377,22 @@ class RecordHandler {
           )
         }
 
-        if (promises) {
+        if (signalPromise && promises.length) {
+          promises.push(signalPromise)
+        }
+
+        if (promises.length) {
           await Promise.race(promises)
+          signal?.throwIfAborted()
         }
       }
 
       {
-        const syncPromise = new Promise((resolve) => this._sync(resolve))
+        const promises = []
 
-        let promises
+        promises.push(new Promise((resolve) => this._sync(resolve)))
 
         if (timeout) {
-          promises ??= []
           promises.push(
             new Promise((resolve, reject) => {
               const serverTimeout = timers.setTimeout(() => {
@@ -390,15 +405,12 @@ class RecordHandler {
         }
 
         if (signalPromise) {
-          promises ??= []
           promises.push(signalPromise)
         }
 
-        if (promises) {
-          promises.push(syncPromise)
+        if (promises.length) {
           await Promise.race(promises)
-        } else {
-          await syncPromise
+          signal?.throwIfAborted()
         }
       }
     } finally {
@@ -554,78 +566,78 @@ class RecordHandler {
    * @returns {rxjs.Observable}
    */
   _observe(defaults, name, ...args) {
-    return new rxjs.Observable((subscriber) => {
-      let path
-      let state = defaults?.state ?? C.RECORD_STATE.CLIENT
-      let signal = null
-      let timeout = defaults?.timeout ?? 0
-      let dataOnly = defaults?.dataOnly ?? false
-      let sync = defaults?.sync ?? false
-
-      let idx = 0
-
-      if (
-        idx < args.length &&
-        (args[idx] == null ||
-          typeof args[idx] === 'string' ||
-          Array.isArray(args[idx]) ||
-          typeof args[idx] === 'function')
-      ) {
-        path = args[idx++]
-      }
-
-      if (idx < args.length && (args[idx] == null || typeof args[idx] === 'number')) {
-        state = args[idx++]
-      }
-
-      if (idx < args.length && (args[idx] == null || typeof args[idx] === 'object')) {
-        const options = args[idx++] || {}
-
-        if (options.signal !== undefined) {
-          signal = options.signal
-        }
+    let path
+    let state = defaults?.state ?? C.RECORD_STATE.CLIENT
+    let signal = null
+    let timeout = defaults?.timeout ?? 0
+    let dataOnly = defaults?.dataOnly ?? false
+    let sync = defaults?.sync ?? false
 
-        if (options.timeout !== undefined) {
-          timeout = options.timeout
-        }
+    let idx = 0
 
-        if (options.path !== undefined) {
-          path = options.path
-        }
+    if (
+      idx < args.length &&
+      (args[idx] == null ||
+        typeof args[idx] === 'string' ||
+        Array.isArray(args[idx]) ||
+        typeof args[idx] === 'function')
+    ) {
+      path = args[idx++]
+    }
 
-        if (options.state !== undefined) {
-          state = options.state
-        }
+    if (idx < args.length && (args[idx] == null || typeof args[idx] === 'number')) {
+      state = args[idx++]
+    }
 
-        if (options.dataOnly !== undefined) {
-          dataOnly = options.dataOnly
-        }
+    if (idx < args.length && (args[idx] == null || typeof args[idx] === 'object')) {
+      const options = args[idx++] || {}
 
-        if (options.sync !== undefined) {
-          sync = options.sync
-        }
+      if (options.signal !== undefined) {
+        signal = options.signal
       }
 
-      if (typeof state === 'string') {
-        state = C.RECORD_STATE[state.toUpperCase()]
+      if (options.timeout !== undefined) {
+        timeout = options.timeout
       }
 
-      if (!Number.isInteger(state) || state < 0) {
-        throw new Error('invalid argument: state')
+      if (options.path !== undefined) {
+        path = options.path
       }
 
-      if (!Number.isInteger(timeout) || timeout < 0) {
-        throw new Error('invalid argument: timeout')
+      if (options.state !== undefined) {
+        state = options.state
       }
 
-      if (typeof dataOnly !== 'boolean') {
-        throw new Error('invalid argument: dataOnly')
+      if (options.dataOnly !== undefined) {
+        dataOnly = options.dataOnly
       }
 
-      if (typeof sync !== 'boolean') {
-        throw new Error('invalid argument: sync')
+      if (options.sync !== undefined) {
+        sync = options.sync
       }
+    }
 
+    if (typeof state === 'string') {
+      state = C.RECORD_STATE[state.toUpperCase()]
+    }
+
+    if (!Number.isInteger(state) || state < 0) {
+      throw new Error('invalid argument: state')
+    }
+
+    if (!Number.isInteger(timeout) || timeout < 0) {
+      throw new Error('invalid argument: timeout')
+    }
+
+    if (typeof dataOnly !== 'boolean') {
+      throw new Error('invalid argument: dataOnly')
+    }
+
+    if (typeof sync !== 'boolean') {
+      throw new Error('invalid argument: sync')
+    }
+
+    return new rxjs.Observable((subscriber) => {
       // TODO (perf): Make a class
       const subscription = {
         /** @readonly @type {unknown} */
@@ -651,6 +663,9 @@ class RecordHandler {
         data: kEmpty,
         /** @type {boolean} */
         synced: false,
+
+        index: -1,
+        onUpdate,
       }
 
       subscriber.add(() => {
@@ -666,7 +681,7 @@ class RecordHandler {
         }
 
         if (subscription.record) {
-          subscription.record.unsubscribe(onUpdate, subscription)
+          subscription.record._unobserve(subscription)
           subscription.record.unref()
           subscription.record = null
         }
@@ -677,11 +692,11 @@ class RecordHandler {
         utils.addAbortListener(subscription.signal, subscription.abort)
       }
 
-      subscription.record = this.getRecord(name).subscribe(onUpdate, subscription)
+      subscription.record = this.getRecord(name)
+      subscription.record._observe(subscription)
 
       if (sync) {
-        // TODO (fix): What about sync timeout?
-        this._sync(onSync, sync === true ? 'WEAK' : sync, subscription)
+        this._sync(onSync, sync, subscription)
       } else {
         onSync(subscription)
       }
@@ -702,8 +717,8 @@ class RecordHandler {
         return true
       }
 
-      const sync = this._syncMap[token]
-      delete this._syncMap[token]
+      const sync = this._syncMap.get(token)
+      this._syncMap.delete(token)
 
       if (!sync) {
         return true
@@ -746,10 +761,10 @@ class RecordHandler {
         this._connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.PUT, update)
       }
 
-      const syncMap = {}
-      for (const sync of Object.values(this._syncMap)) {
+      const syncMap = new Map()
+      for (const sync of this._syncMap.values()) {
         const token = xuid()
-        syncMap[token] = sync
+        syncMap.set(token, sync)
         this._connection.sendMsg(
           C.TOPIC.RECORD,
           C.ACTIONS.SYNC,
@@ -784,7 +799,7 @@ class RecordHandler {
       const token = xuid()
       const queue = this._syncQueue.splice(0)
 
-      this._syncMap[token] = { queue, type }
+      this._syncMap.set(token, { queue, type })
       this._connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.SYNC, type ? [token, type] : [token])
     }, 1)
   }

package/src/record/record.d.ts

@@ -60,6 +60,8 @@ export default class Record<Data = unknown> {
   get: {
     // with path
     <P extends string | string[]>(path: P): Get<Data, P>
+    // with function mapper
+    <R>(fn: (data: Data) => R): R
     // without path
     (): Data
     (path: undefined | string | string[]): unknown

package/src/record/record.js

@@ -20,7 +20,13 @@ class Record {
     this._state = C.RECORD_STATE.VOID
     this._refs = 0
     this._subscriptions = []
-    this._emitting = false
+
+    /** @type {Array|null} */
+    this._emittingArr = null
+    /** @type {number} */
+    this._emittingIndex = -1
+
+    this._observers = []
 
     /** @type Map? */ this._updating = null
     /** @type Array? */ this._patching = null
@@ -88,9 +94,8 @@ class Record {
    * @returns {Record}
    */
   subscribe(fn, opaque = null) {
-    if (this._emitting) {
+    if (this._emittingArr == this._subscriptions) {
       this._subscriptions = this._subscriptions.slice()
-      this._emitting = false
     }
 
     this._subscriptions.push(fn, opaque)
@@ -105,9 +110,8 @@ class Record {
    * @returns {Record}
    */
   unsubscribe(fn, opaque = null) {
-    if (this._emitting) {
+    if (this._emittingArr == this._subscriptions) {
       this._subscriptions = this._subscriptions.slice()
-      this._emitting = false
     }
 
     let idx = -1
@@ -128,6 +132,41 @@ class Record {
     return this
   }
 
+  /**
+   * @note Subscribers are unordered.
+   * @param {{ index: number, onUpdate: (Record) => void}} subscription
+   */
+  _observe(subscription) {
+    if (subscription.index != null && subscription.index !== -1) {
+      throw new Error('already observing')
+    }
+
+    subscription.index = this._observers.push(subscription) - 1
+  }
+
+  /**
+   * @param {{ index: number, onUpdate: (Record) => void}} subscription
+   */
+  _unobserve(subscription) {
+    if (subscription.index == null || subscription.index === -1) {
+      throw new Error('not observing')
+    }
+
+    if (this._emittingArr === this._observers) {
+      // TODO (perf): Shift from start if emitting?
+      this._observers = this._observers.slice()
+    }
+
+    const idx = subscription.index
+    const tmp = this._observers.pop()
+    subscription.index = -1
+
+    if (tmp !== subscription) {
+      this._observers[idx] = tmp
+      this._observers[idx].index = idx
+    }
+  }
+
   get(path) {
     if (!path) {
       return this._data
@@ -515,18 +554,41 @@ class Record {
   }
 
   _emitUpdate() {
-    this._emitting = true
+    if (this._emittingArr != null) {
+      throw new Error('cannot reenter emitUpdate')
+    }
 
-    const arr = this._subscriptions
-    const len = arr.length
+    try {
+      const arr = this._subscriptions
+      const len = arr.length
 
-    for (let n = 0; n < len; n += 2) {
-      arr[n + 0](this, arr[n + 1])
+      this._emittingArr = arr
+      for (let n = 0; n < len; n += 2) {
+        this._emittingIndex = n
+        // TODO (fix): What if this throws?
+        arr[n + 0](this, arr[n + 1])
+      }
+    } finally {
+      this._emittingArr = null
+      this._emittingIndex = -1
     }
 
-    this._handler._client.emit('recordUpdated', this)
+    try {
+      const arr = this._observers
+      const len = arr.length
 
-    this._emitting = false
+      this._emittingArr = arr
+      for (let n = 0; n < len; n++) {
+        this._emittingIndex = n
+        // TODO (fix): What if this throws?
+        arr[n].onUpdate(this, arr[n])
+      }
+    } finally {
+      this._emittingArr = null
+      this._emittingIndex = -1
+    }
+
+    this._handler._client.emit('recordUpdated', this)
   }
 }
 

package/src/rpc/rpc-handler.d.ts

@@ -13,7 +13,7 @@ export default class RpcHandler<
     callback: (
       args: Methods[Name][0],
       response: RpcResponse<Methods[Name][1]>,
-    ) => Methods[Name][1] | Promise<Methods[Name][1]> | void,
+    ) => Methods[Name][1] | Promise<Methods[Name][1]> | Promise<void> | void,
   ) => UnprovideFn | void
 
   unprovide: <Name extends keyof Methods>(name: Name) => void

package/src/utils/legacy-listener.js

@@ -0,0 +1,252 @@
+import * as rxjs from 'rxjs'
+import * as C from '../constants/constants.js'
+import { h64ToString, findBigIntPaths } from './utils.js'
+
+export default class Listener {
+  constructor(topic, pattern, callback, handler, { recursive = false, stringify = null } = {}) {
+    this._topic = topic
+    this._pattern = pattern
+    this._callback = callback
+    this._handler = handler
+    this._client = this._handler._client
+    this._connection = this._handler._connection
+    this._subscriptions = new Map()
+    this._recursive = recursive
+    this._stringify = stringify || JSON.stringify
+
+    this._$onConnectionStateChange()
+  }
+
+  get connected() {
+    return this._connection.connected
+  }
+
+  get stats() {
+    return {
+      subscriptions: this._subscriptions.size,
+    }
+  }
+
+  _$destroy() {
+    this._reset()
+
+    if (this.connected) {
+      this._connection.sendMsg(this._topic, C.ACTIONS.UNLISTEN, [this._pattern])
+    }
+  }
+
+  _$onMessage(message) {
+    if (!this.connected) {
+      this._client._$onError(
+        C.TOPIC.RECORD,
+        C.EVENT.NOT_CONNECTED,
+        new Error('received message while not connected'),
+        message,
+      )
+      return
+    }
+
+    const name = message.data[1]
+
+    if (message.action === C.ACTIONS.SUBSCRIPTION_FOR_PATTERN_FOUND) {
+      if (this._subscriptions.has(name)) {
+        this._error(name, 'invalid add: listener exists')
+        return
+      }
+
+      // TODO (refactor): Move to class
+      const provider = {
+        name,
+        value$: null,
+        sending: false,
+        accepted: false,
+        version: null,
+        timeout: null,
+        patternSubscription: null,
+        valueSubscription: null,
+      }
+      provider.stop = () => {
+        if (this.connected && provider.accepted) {
+          this._connection.sendMsg(this._topic, C.ACTIONS.LISTEN_REJECT, [
+            this._pattern,
+            provider.name,
+          ])
+        }
+
+        provider.value$ = null
+        provider.version = null
+        provider.accepted = false
+        provider.sending = false
+
+        clearTimeout(provider.timeout)
+        provider.timeout = null
+
+        provider.patternSubscription?.unsubscribe()
+        provider.patternSubscription = null
+
+        provider.valueSubscription?.unsubscribe()
+        provider.valueSubscription = null
+      }
+      provider.send = () => {
+        provider.sending = false
+
+        if (!provider.patternSubscription) {
+          return
+        }
+
+        const accepted = Boolean(provider.value$)
+        if (provider.accepted === accepted) {
+          return
+        }
+
+        this._connection.sendMsg(
+          this._topic,
+          accepted ? C.ACTIONS.LISTEN_ACCEPT : C.ACTIONS.LISTEN_REJECT,
+          [this._pattern, provider.name],
+        )
+
+        provider.version = null
+        provider.accepted = accepted
+      }
+      provider.next = (value$) => {
+        if (!value$) {
+          value$ = null
+        } else if (typeof value$.subscribe !== 'function') {
+          value$ = rxjs.of(value$) // Compat for recursive with value
+        }
+
+        if (Boolean(provider.value$) !== Boolean(value$) && !provider.sending) {
+          provider.sending = true
+          queueMicrotask(provider.send)
+        }
+
+        provider.value$ = value$
+
+        if (provider.valueSubscription) {
+          provider.valueSubscription.unsubscribe()
+          provider.valueSubscription = provider.value$?.subscribe(provider.observer)
+        }
+      }
+      provider.error = (err) => {
+        provider.stop()
+        // TODO (feat): backoff retryCount * delay?
+        // TODO (feat): backoff option?
+        provider.timeout = setTimeout(() => {
+          provider.start()
+        }, 10e3)
+        this._error(provider.name, err)
+      }
+      provider.observer = {
+        next: (value) => {
+          if (value == null) {
+            provider.next(null) // TODO (fix): This is weird...
+            return
+          }
+
+          if (this._topic === C.TOPIC.EVENT) {
+            this._handler.emit(provider.name, value)
+          } else if (this._topic === C.TOPIC.RECORD) {
+            if (typeof value !== 'object' && typeof value !== 'string') {
+              this._error(provider.name, 'invalid value')
+              return
+            }
+
+            if (typeof value !== 'string') {
+              try {
+                value = this._stringify(value)
+              } catch (err) {
+                const bigIntPaths = /BigInt/.test(err.message) ? findBigIntPaths(value) : undefined
+                this._error(
+                  Object.assign(new Error(`invalid value: ${value}`), {
+                    cause: err,
+                    data: { name: provider.name, bigIntPaths },
+                  }),
+                )
+                return
+              }
+            }
+
+            const body = value
+            const hash = h64ToString(body)
+            const version = `INF-${hash}`
+
+            if (provider.version !== version) {
+              provider.version = version
+              this._connection.sendMsg(C.TOPIC.RECORD, C.ACTIONS.UPDATE, [
+                provider.name,
+                version,
+                body,
+              ])
+            }
+          }
+        },
+        error: provider.error,
+      }
+      provider.start = () => {
+        try {
+          const ret$ = this._callback(name)
+          if (this._recursive && typeof ret$?.subscribe === 'function') {
+            provider.patternSubscription = ret$.subscribe(provider)
+          } else {
+            provider.patternSubscription = rxjs.of(ret$).subscribe(provider)
+          }
+        } catch (err) {
+          this._error(provider.name, err)
+        }
+      }
+
+      provider.start()
+
+      this._subscriptions.set(provider.name, provider)
+    } else if (message.action === C.ACTIONS.LISTEN_ACCEPT) {
+      const provider = this._subscriptions.get(name)
+      if (!provider?.value$) {
+        return
+      }
+
+      if (provider.valueSubscription) {
+        this._error(
+          name,
+          'invalid accept: listener started (pattern:' + this._pattern + ' name:' + name + ')',
+        )
+      } else {
+        // TODO (fix): provider.version = message.data[2]
+        provider.valueSubscription = provider.value$.subscribe(provider.observer)
+      }
+    } else if (message.action === C.ACTIONS.SUBSCRIPTION_FOR_PATTERN_REMOVED) {
+      const provider = this._subscriptions.get(name)
+
+      if (!provider) {
+        this._error(
+          name,
+          'invalid remove: listener missing (pattern:' + this._pattern + ' name:' + name + ')',
+        )
+      } else {
+        provider.stop()
+        this._subscriptions.delete(provider.name)
+      }
+    } else {
+      return false
+    }
+    return true
+  }
+
+  _$onConnectionStateChange() {
+    if (this.connected) {
+      this._connection.sendMsg(this._topic, C.ACTIONS.LISTEN, [this._pattern])
+    } else {
+      this._reset()
+    }
+  }
+
+  _error(name, err) {
+    this._client._$onError(this._topic, C.EVENT.LISTENER_ERROR, err, [this._pattern, name])
+  }
+
+  _reset() {
+    for (const provider of this._subscriptions.values()) {
+      provider.stop()
+    }
+    this._subscriptions.clear()
+  }
+}

package/src/utils/utils.js

@@ -3,6 +3,8 @@ import xxhash from 'xxhash-wasm'
 const NODE_ENV = typeof process !== 'undefined' && process.env && process.env.NODE_ENV
 const HASHER = await xxhash()
 
+// This is a hack to avoid top-level await
+// const HASHER = await xxhash()
 export const isNode = typeof process !== 'undefined' && process.toString() === '[object process]'
 export const isProduction = NODE_ENV === 'production'