@shipload/sdk 1.0.0-next.0 → 1.0.0-next.2

package/package.json

@@ -1,8 +1,13 @@
 {
     "name": "@shipload/sdk",
     "description": "SDKs for Shipload",
-    "version": "1.0.0-next.0",
-    "homepage": "https://github.com/shipload/sdk",
+    "version": "1.0.0-next.2",
+    "homepage": "https://github.com/shipload/toolkit/tree/master/packages/sdk",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/shipload/toolkit.git",
+        "directory": "packages/sdk"
+    },
     "license": "MIT",
     "main": "lib/shipload.js",
     "module": "lib/shipload.m.js",

package/src/subscriptions/connection.ts

@@ -7,6 +7,9 @@ export interface WebSocketConnectionOptions {
     url: string
     onMessage: (message: ServerMessage) => void
     onStateChange?: (state: ConnectionState) => void
+    minReconnectDelay?: number
+    pingIntervalMs?: number
+    pongTimeoutMs?: number
 }
 
 export class WebSocketConnection {
@@ -19,15 +22,26 @@ export class WebSocketConnection {
     private _state: ConnectionState = 'disconnected'
     private shouldReconnect = true
     private sendQueue: string[] = []
+    private minReconnectDelay: number
+    private pingIntervalMs: number
+    private pongTimeoutMs: number
+    private pingTimer: ReturnType<typeof setInterval> | null = null
+    private staleTimer: ReturnType<typeof setTimeout> | null = null
 
-    private static readonly MIN_RECONNECT_DELAY = 1000
+    private static readonly DEFAULT_MIN_RECONNECT_DELAY = 1000
     private static readonly MAX_RECONNECT_DELAY = 30000
     private static readonly RECONNECT_MULTIPLIER = 2
+    private static readonly DEFAULT_PING_INTERVAL_MS = 25000
+    private static readonly DEFAULT_PONG_TIMEOUT_MS = 10000
 
     constructor(options: WebSocketConnectionOptions) {
         this.url = options.url
         this.onMessage = options.onMessage
         this.onStateChange = options.onStateChange
+        this.minReconnectDelay =
+            options.minReconnectDelay ?? WebSocketConnection.DEFAULT_MIN_RECONNECT_DELAY
+        this.pingIntervalMs = options.pingIntervalMs ?? WebSocketConnection.DEFAULT_PING_INTERVAL_MS
+        this.pongTimeoutMs = options.pongTimeoutMs ?? WebSocketConnection.DEFAULT_PONG_TIMEOUT_MS
     }
 
     get state(): ConnectionState {
@@ -64,9 +78,11 @@ export class WebSocketConnection {
                 ) {
                     this.ws.send(this.sendQueue.shift()!)
                 }
+                this.startHeartbeat()
             }
 
             this.ws.onmessage = (event) => {
+                this.resetStaleTimer()
                 try {
                     const message = JSON.parse(event.data) as ServerMessage
                     this.onMessage(message)
@@ -77,6 +93,7 @@ export class WebSocketConnection {
             }
 
             this.ws.onclose = () => {
+                this.stopHeartbeat()
                 this.ws = null
                 this.sendQueue.length = 0
 
@@ -104,7 +121,7 @@ export class WebSocketConnection {
         }
 
         const delay = Math.min(
-            WebSocketConnection.MIN_RECONNECT_DELAY *
+            this.minReconnectDelay *
                 WebSocketConnection.RECONNECT_MULTIPLIER ** this.reconnectAttempts,
             WebSocketConnection.MAX_RECONNECT_DELAY
         )
@@ -126,6 +143,8 @@ export class WebSocketConnection {
             this.reconnectTimeout = null
         }
 
+        this.stopHeartbeat()
+
         if (this.ws) {
             this.ws.close()
             this.ws = null
@@ -135,6 +154,35 @@ export class WebSocketConnection {
         this.setState('disconnected')
     }
 
+    private startHeartbeat() {
+        this.stopHeartbeat()
+        this.resetStaleTimer()
+        this.pingTimer = setInterval(() => {
+            if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+                this.ws.send(JSON.stringify({type: 'ping'}))
+            }
+        }, this.pingIntervalMs)
+    }
+
+    private stopHeartbeat() {
+        if (this.pingTimer) {
+            clearInterval(this.pingTimer)
+            this.pingTimer = null
+        }
+        if (this.staleTimer) {
+            clearTimeout(this.staleTimer)
+            this.staleTimer = null
+        }
+    }
+
+    private resetStaleTimer() {
+        if (this.staleTimer) clearTimeout(this.staleTimer)
+        this.staleTimer = setTimeout(() => {
+            debug('No frames within ping interval + pong timeout — forcing reconnect')
+            if (this.ws) this.ws.close()
+        }, this.pingIntervalMs + this.pongTimeoutMs)
+    }
+
     close() {
         this.disconnect()
     }

package/src/subscriptions/manager.ts

@@ -1,4 +1,4 @@
-import {WebSocketConnection} from './connection'
+import {WebSocketConnection, type ConnectionState} from './connection'
 import type {
     BoundingBox,
     BoundsDeltaMessage,
@@ -22,6 +22,9 @@ export type EntityInstance = Ship | Warehouse | Container
 
 export interface SubscriptionsOptions {
     url: string
+    minReconnectDelay?: number
+    pingIntervalMs?: number
+    pongTimeoutMs?: number
 }
 
 export interface BoundsSubscriptionHandle {
@@ -53,6 +56,9 @@ export class SubscriptionsManager {
     private readonly boundsSubs = new Map<
         string,
         {
+            bounds?: BoundingBox
+            owner?: string
+            prioritizeOwner?: string
             onSnapshot?: (entities: EntityInstance[]) => void
             onUpdate?: (entity: EntityInstance) => void
             onBoundsDelta?: (entered: EntityInstance[], exited: number[]) => void
@@ -60,11 +66,16 @@ export class SubscriptionsManager {
         }
     >()
     private subCounter = 0
+    private hasConnected = false
 
     constructor(opts: SubscriptionsOptions) {
         this.conn = new WebSocketConnection({
             url: opts.url,
             onMessage: (m) => this.onMessage(m),
+            onStateChange: (s) => this.onStateChange(s),
+            minReconnectDelay: opts.minReconnectDelay,
+            pingIntervalMs: opts.pingIntervalMs,
+            pongTimeoutMs: opts.pongTimeoutMs,
         })
         this.conn.connect()
     }
@@ -139,6 +150,9 @@ export class SubscriptionsManager {
             current: new Map(),
         }
         this.boundsSubs.set(subId, {
+            bounds,
+            owner: handlers.owner,
+            prioritizeOwner: handlers.prioritizeOwner,
             onSnapshot: handlers.onSnapshot,
             onUpdate: handlers.onUpdate,
             onBoundsDelta: handlers.onBoundsDelta,
@@ -154,10 +168,39 @@ export class SubscriptionsManager {
     }
 
     private updateBounds(subId: string, bounds: BoundingBox) {
+        const entry = this.boundsSubs.get(subId)
+        if (entry) entry.bounds = bounds
         const msg: UpdateBoundsMessage = {type: 'update_bounds', sub_id: subId, bounds}
         this.sendMessage(msg)
     }
 
+    private onStateChange(state: ConnectionState) {
+        if (state !== 'connected') return
+        if (!this.hasConnected) {
+            this.hasConnected = true
+            return
+        }
+        for (const [subId, entry] of this.entitySubs) {
+            const msg: SubscribeEntityMessage = {
+                type: 'subscribe_entity',
+                sub_id: subId,
+                entity_type: entry.type,
+                entity_id: entry.id,
+            }
+            this.sendMessage(msg)
+        }
+        for (const [subId, entry] of this.boundsSubs) {
+            const msg: SubscribeMessage = {
+                type: 'subscribe',
+                sub_id: subId,
+                bounds: entry.bounds,
+                owner: entry.owner,
+                prioritize_owner: entry.prioritizeOwner,
+            }
+            this.sendMessage(msg)
+        }
+    }
+
     private onMessage(msg: ServerMessage) {
         switch (msg.type) {
             case 'snapshot':