@nxtedition/deepstream.io-client-js 31.2.2 → 31.2.4

package/package.json

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

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

@@ -3,11 +3,11 @@ import { Observable } from 'rxjs'
 export default class EventHandler {
   connected: boolean
   stats: EventStats
-  subscribe: (name: string, callback: () => void) => void
-  unsubscribe: (name: string, callback: () => void) => void
-  on: (name: string, callback: () => void) => this
-  once: (name: string, callback: () => void) => this
-  off: (name: string, callback: () => void) => this
+  subscribe: (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
   observe: <Data>(name: string) => Observable<Data>
   emit: <Data>(name: string, data?: Data) => void
   provide: (pattern: string, callback: (name: string) => void, options: unknown) => () => void

package/src/record/record-handler.js

@@ -9,6 +9,8 @@ import * as utils from '../utils/utils.js'
 import xuid from 'xuid'
 import * as timers from '../utils/timers.js'
 
+/** @import {Timeout} from '../utils/timers.js' */
+
 function noop() {}
 
 const kEmpty = Symbol('kEmpty')
@@ -41,17 +43,24 @@ function onUpdate(record, subscription) {
     return
   }
 
-  if (!subscription.synced) {
-    return
-  }
-
-  if (subscription.state && subscription.record.state < subscription.state) {
+  if (!subscription.synced || subscription.record.state < subscription.state) {
+    if (subscription.timeoutValue > 0) {
+      if (!subscription.timeoutHandle) {
+        subscription.timeoutHandle = timers.setTimeout(
+          onTimeout,
+          subscription.timeoutValue,
+          subscription,
+        )
+      } else {
+        subscription.timeoutHandle.refresh()
+      }
+    }
     return
   }
 
-  if (subscription.timeout) {
-    timers.clearTimeout(subscription.timeout)
-    subscription.timeout = null
+  if (subscription.timeoutHandle) {
+    timers.clearTimeout(subscription.timeoutHandle)
+    subscription.timeoutHandle = null
   }
 
   const data = subscription.path
@@ -542,11 +551,11 @@ class RecordHandler {
   _observe(defaults, name, ...args) {
     return new rxjs.Observable((subscriber) => {
       let path
-      let state = defaults?.state
-      let signal
-      let timeout = defaults?.timeout
-      let dataOnly = defaults?.dataOnly
-      let sync = defaults?.sync
+      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
 
@@ -596,31 +605,61 @@ class RecordHandler {
         state = C.RECORD_STATE[state.toUpperCase()]
       }
 
+      // TODO (fix): Validate path?
+      // TODO (fix): Validate signal?
+
+      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')
+      }
+
       // TODO (perf): Make a class
       const subscription = {
+        /** @readonly @type {unknown} */
         subscriber,
+        /** @type {Record|null} */
+        record: this.getRecord(name),
+        /** @readonly @type {unknown} */
         path,
+        /** @readonly @type {number} */
         state,
-        synced: false,
+        /** @type {AbortSignal|null} */
         signal,
+        /** @readonly @type {boolean} */
         dataOnly,
-        data: kEmpty,
-        /** @type {NodeJS.Timeout|Timeout|null} */
-        timeout: null,
-        /** @type {Record?} */
-        record: null,
+        /** @readonly @type {number} */
+        timeoutValue: timeout,
+
+        /** @type {Timeout|null} */
+        timeoutHandle: null,
         /** @type {Function?} */
         abort: null,
+        /** @type {object|Array} */
+        data: kEmpty,
+        /** @type {boolean} */
+        synced: false,
+
         unsubscribe() {
-          if (this.timeout) {
-            timers.clearTimeout(this.timeout)
-            this.timeout = null
+          if (this.timeoutHandle) {
+            timers.clearTimeout(this.timeoutHandle)
+            this.timeoutHandle = null
           }
 
           if (this.signal) {
             utils.removeAbortListener(this.signal, this.abort)
-            this.signal = null
             this.abort = null
+            this.signal = null
           }
 
           if (this.record) {
@@ -631,30 +670,22 @@ class RecordHandler {
         },
       }
 
-      subscription.record = this.getRecord(name).subscribe(onUpdate, subscription)
-
-      const record = subscription.record
-
-      if (sync && record.state >= C.RECORD_STATE.SERVER) {
-        this._sync(onSync, sync === true ? 'WEAK' : sync, subscription)
-      } else {
-        subscription.synced = true
-      }
+      if (subscription.record) {
+        subscription.record.subscribe(onUpdate, subscription)
 
-      if (timeout > 0 && state && record.state < state) {
-        // TODO (perf): Avoid Timer allocation.
-        subscription.timeout = timers.setTimeout(onTimeout, timeout, subscription)
+        if (sync && subscription.record.state >= C.RECORD_STATE.SERVER) {
+          this._sync(onSync, sync === true ? 'WEAK' : sync, subscription)
+        } else {
+          subscription.synced = true
+        }
       }
 
-      if (signal) {
-        // TODO (perf): Avoid abort closure allocation.
+      if (subscription.signal) {
         subscription.abort = () => subscriber.error(new utils.AbortError())
-        utils.addAbortListener(signal, subscription.abort)
+        utils.addAbortListener(subscription.signal, subscription.abort)
       }
 
-      if (record.version) {
-        onUpdate(null, subscription)
-      }
+      onUpdate(subscription.record, subscription)
 
       return subscription
     })

package/src/utils/timers.js

@@ -49,7 +49,7 @@ function refreshTimeout() {
   }
 }
 
-class Timeout {
+class FastTimeout {
   constructor(callback, delay, opaque) {
     this.callback = callback
     this.delay = delay
@@ -84,14 +84,32 @@ class Timeout {
   }
 }
 
+/**
+ * @typedef {{
+ *  refresh: () => void,
+ *  [Symbol.dispose]: () => void,
+ * }} Timeout
+ */
+
+/**
+ * @param {(opaque?: any) => void} callback
+ * @param {number} delay
+ * @param {any} [opaque]
+ * @returns {Timeout}
+ */
 export function setTimeout(callback, delay, opaque) {
   return delay < fastNowInterval
-    ? globalThis.setTimeout(callback, delay, opaque)
-    : new Timeout(callback, delay, opaque)
+    ? opaque
+      ? globalThis.setTimeout(() => callback(opaque), delay)
+      : globalThis.setTimeout(callback, delay)
+    : new FastTimeout(callback, delay, opaque)
 }
 
+/**
+ * @param {Timeout} timeout
+ */
 export function clearTimeout(timeout) {
-  if (timeout instanceof Timeout) {
+  if (timeout instanceof FastTimeout) {
     timeout.clear()
   } else {
     globalThis.clearTimeout(timeout)

package/.claude/settings.local.json

@@ -1,9 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(npm run test:types:*)"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}