@mikrojs/native 0.5.1 → 0.6.0-pr-70.gc88e298

package/runtime/udp/udp.ts

@@ -1,8 +1,10 @@
+import {Observable} from 'mikrojs/observable'
 import {ok} from 'mikrojs/result'
 import {bind as nativeBind, type NativeUdpSocket} from 'native:udp'
 
+import type {Subscriber} from '../observable/types.js'
 import type {Result} from '../result/types.js'
-import type {BindOptions, MulticastGroup, PeerAddress, UdpError, UdpSocket} from './types.js'
+import type {BindOptions, MulticastGroup, UdpError, UdpMessage, UdpSocket} from './types.js'
 
 const utf8 = new TextEncoder()
 
@@ -11,7 +13,37 @@ function toBytes(data: Uint8Array | string): Uint8Array {
 }
 
 function makeSocket(handle: NativeUdpSocket): UdpSocket {
-  let onMessage: ((msg: Uint8Array, from: PeerAddress) => void) | null = null
+  /* Lazy native attach: keep handle.setOnMessage in sync with whether any
+   * JS subscriber is listening. With zero subscribers, the native side
+   * skips JS dispatch and increments the dropped counter for inbound
+   * packets — preserving the pre-Observable behavior of unset onMessage
+   * silently discarding traffic. */
+  const subscribers: Subscriber<UdpMessage>[] = []
+  let closed = false
+
+  const onMessage = new Observable<UdpMessage>((sub) => {
+    if (closed) {
+      sub.complete()
+      return
+    }
+    subscribers.push(sub)
+    if (subscribers.length === 1) {
+      handle.setOnMessage((msg, from) => {
+        /* Snapshot so unsubscribes during dispatch don't shift indices. */
+        const snapshot = subscribers.slice()
+        for (const s of snapshot) {
+          if (!s.closed) s.next({msg, from})
+        }
+      })
+    }
+    sub.addTeardown(() => {
+      const i = subscribers.indexOf(sub)
+      if (i >= 0) subscribers.splice(i, 1)
+      if (subscribers.length === 0 && !closed) {
+        handle.setOnMessage(null)
+      }
+    })
+  })
 
   const sock: UdpSocket = {
     get port() {
@@ -26,13 +58,7 @@ function makeSocket(handle: NativeUdpSocket): UdpSocket {
     set dropped(value: number) {
       handle.dropped = value
     },
-    get onMessage() {
-      return onMessage
-    },
-    set onMessage(fn) {
-      onMessage = fn
-      handle.setOnMessage(fn)
-    },
+    onMessage,
     send(data, to) {
       return handle.send(toBytes(data), to)
     },
@@ -43,6 +69,16 @@ function makeSocket(handle: NativeUdpSocket): UdpSocket {
       return handle.leaveMulticastGroup(group.address)
     },
     close() {
+      if (closed) return
+      closed = true
+      handle.setOnMessage(null)
+      /* Complete any active subscriptions. Walk a snapshot in case a
+       * complete handler unsubscribes a sibling. */
+      const snapshot = subscribers.slice()
+      subscribers.length = 0
+      for (const s of snapshot) {
+        if (!s.closed) s.complete()
+      }
       handle.close()
     },
   }

package/runtime/wifi/types.ts

@@ -1,3 +1,4 @@
+import type {Observable} from '../observable/types.js'
 import type {Result} from '../result/types.js'
 
 export type WifiStatus =
@@ -87,17 +88,6 @@ export interface ApStartOptions {
   maxConnections?: number
 }
 
-export interface WifiEventMap {
-  connect: (info: WifiConnectionInfo) => void
-  disconnect: (reason: WifiDisconnectReason) => void
-  'rssi-low': (rssi: number) => void
-}
-
-export interface ApEventMap {
-  'station-connect': (info: ApStationInfo) => void
-  'station-disconnect': (info: ApStationInfo) => void
-}
-
 export type WifiError =
   | {name: 'InitFailed'; message: string}
   | {name: 'CountryNotSet'}
@@ -122,8 +112,8 @@ export interface WifiAp {
   readonly stations: ApStationInfo[]
   deauthStation(mac: string): Result<void, WifiError>
   inactiveTimeout: number
-  on<K extends keyof ApEventMap>(event: K, listener: ApEventMap[K]): void
-  off<K extends keyof ApEventMap>(event: K, listener: ApEventMap[K]): void
+  readonly onStationConnect: Observable<ApStationInfo>
+  readonly onStationDisconnect: Observable<ApStationInfo>
 }
 
 export interface Wifi {
@@ -135,8 +125,9 @@ export interface Wifi {
   isConnected: boolean
   scan(opts?: ScanOptions): Promise<Result<ScanResult[], WifiError>>
 
-  on<K extends keyof WifiEventMap>(event: K, listener: WifiEventMap[K]): void
-  off<K extends keyof WifiEventMap>(event: K, listener: WifiEventMap[K]): void
+  readonly onConnect: Observable<WifiConnectionInfo>
+  readonly onDisconnect: Observable<WifiDisconnectReason>
+  readonly onRssiLow: Observable<number>
 
   readonly mac: string
   hostname: string | undefined

package/runtime/wifi/wifi.ts

@@ -1,9 +1,9 @@
+import {Observable} from 'mikrojs/observable'
 import {err, ok} from 'mikrojs/result'
 import {Wifi as NativeWifi} from 'native:wifi'
 
 import type {Result} from '../result/types.js'
 import type {
-  ApEventMap,
   ApStartOptions,
   ApStationInfo,
   IpConfig,
@@ -15,8 +15,8 @@ import type {
   WifiAp,
   WifiConnectionInfo,
   WifiCountryCode,
+  WifiDisconnectReason,
   WifiError,
-  WifiEventMap,
   WifiStatus,
 } from './types.js'
 
@@ -37,6 +37,23 @@ const StatusFromCode = new Map<number, WifiStatus>(
 
 const native = new NativeWifi()
 
+/* One Observable per event type, each backed by a single native.on
+ * registration. Subscribers share that registration via the multicast
+ * source from Observable.withEmitters() — registering the listener once
+ * keeps the C-level callback list at minimum size regardless of how many
+ * JS subscribers are attached. */
+const _onConnect = Observable.withEmitters<WifiConnectionInfo>()
+const _onDisconnect = Observable.withEmitters<WifiDisconnectReason>()
+const _onRssiLow = Observable.withEmitters<number>()
+const _onStationConnect = Observable.withEmitters<ApStationInfo>()
+const _onStationDisconnect = Observable.withEmitters<ApStationInfo>()
+
+native.on('connect', (info) => _onConnect.next(info as WifiConnectionInfo))
+native.on('disconnect', (reason) => _onDisconnect.next(reason as WifiDisconnectReason))
+native.on('rssi-low', (rssi) => _onRssiLow.next(rssi as number))
+native.on('station-connect', (info) => _onStationConnect.next(info as ApStationInfo))
+native.on('station-disconnect', (info) => _onStationDisconnect.next(info as ApStationInfo))
+
 const ap: WifiAp = {
   start(options: ApStartOptions): Result<void, WifiError> {
     return native.apStart(options as Parameters<typeof native.apStart>[0])
@@ -71,13 +88,8 @@ const ap: WifiAp = {
     native.apSetInactiveTimeout(seconds)
   },
 
-  on<K extends keyof ApEventMap>(event: K, listener: ApEventMap[K]) {
-    native.on(event, listener as (...args: unknown[]) => void)
-  },
-
-  off<K extends keyof ApEventMap>(event: K, listener: ApEventMap[K]) {
-    native.off(event, listener as (...args: unknown[]) => void)
-  },
+  onStationConnect: _onStationConnect.observable,
+  onStationDisconnect: _onStationDisconnect.observable,
 }
 
 const MAX_CONNECT_RETRIES = 5
@@ -135,13 +147,9 @@ const wifi: Wifi = {
     return ok(asyncResult.value as ScanResult[])
   },
 
-  on<K extends keyof WifiEventMap>(event: K, listener: WifiEventMap[K]) {
-    native.on(event, listener as (...args: unknown[]) => void)
-  },
-
-  off<K extends keyof WifiEventMap>(event: K, listener: WifiEventMap[K]) {
-    native.off(event, listener as (...args: unknown[]) => void)
-  },
+  onConnect: _onConnect.observable,
+  onDisconnect: _onDisconnect.observable,
+  onRssiLow: _onRssiLow.observable,
 
   get mac(): string {
     const result = native.mac()