@mikrojs/native 0.6.0-pr-72.g464c29c → 0.6.0

package/runtime/udp/types.ts

@@ -1,3 +1,4 @@
+import type {Observable} from '../observable/types.js'
 import type {Result} from '../result/types.js'
 
 export type UdpFamily = 'ipv4' | 'ipv6'
@@ -31,19 +32,31 @@ export type UdpError =
   | {name: 'Closed'}
   | {name: 'NotBound'}
 
+/** Inbound datagram delivered via `socket.onMessage`. */
+export interface UdpMessage {
+  msg: Uint8Array
+  from: PeerAddress
+}
+
 export interface UdpSocket {
   readonly port: number
   readonly family: UdpFamily | 'dual'
   /**
    * Counter incremented each time an inbound datagram is dropped:
    * - the per-socket queue is full,
-   * - no `onMessage` handler is set when a packet arrives,
+   * - no subscriber is attached to `onMessage` when a packet arrives,
    * - or the datagram is larger than the 1500-byte receive buffer
    *   (typical Ethernet MTU; covers CoAP / mDNS / SNTP / DNS).
    */
   dropped: number
 
-  onMessage: ((msg: Uint8Array, from: PeerAddress) => void) | null
+  /**
+   * Stream of inbound datagrams. Subscribing attaches the native dispatch
+   * once the first subscriber is added; the last `unsubscribe()` detaches
+   * it again. Multiple subscribers fan out from one native registration.
+   * Completes when `close()` is called.
+   */
+  readonly onMessage: Observable<UdpMessage>
 
   send(data: Uint8Array | string, to: PeerAddress): Promise<Result<void, UdpError>>
   joinMulticastGroup(group: MulticastGroup): Result<void, UdpError>

package/runtime/udp/udp.ts

@@ -1,8 +1,10 @@
 import {ok} from 'mikrojs/result'
+import {Observable} from 'native:observable'
 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,11 +125,12 @@ 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
+  readonly hostname: string | undefined
   ipConfig(): Result<IpConfig | undefined, WifiError>
   ipConfig(opts: StaticIpConfig): Result<void, WifiError>
   ipConfig(opts?: StaticIpConfig): Result<IpConfig | undefined, WifiError> | Result<void, WifiError>
@@ -150,7 +141,7 @@ export interface Wifi {
   rssiThreshold: number
 
   powerSave: PowerSaveMode
-  country: WifiCountryCode | undefined
+  readonly country: WifiCountryCode | undefined
 }
 
 export declare const wifi: Wifi

package/runtime/wifi/wifi.ts

@@ -1,9 +1,9 @@
+import {lazyEvent} from 'mikrojs/observable/lazy'
 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'
 
@@ -71,13 +71,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: lazyEvent<ApStationInfo>(native, 'station-connect'),
+  onStationDisconnect: lazyEvent<ApStationInfo>(native, 'station-disconnect'),
 }
 
 const MAX_CONNECT_RETRIES = 5
@@ -135,13 +130,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: lazyEvent<WifiConnectionInfo>(native, 'connect'),
+  onDisconnect: lazyEvent<WifiDisconnectReason>(native, 'disconnect'),
+  onRssiLow: lazyEvent<number>(native, 'rssi-low'),
 
   get mac(): string {
     const result = native.mac()
@@ -152,12 +143,6 @@ const wifi: Wifi = {
     return native.getHostname()
   },
 
-  set hostname(value: string | undefined) {
-    if (value !== undefined) {
-      native.setHostname(value)
-    }
-  },
-
   ipConfig: ((
     opts?: StaticIpConfig,
   ): Result<IpConfig | undefined, WifiError> | Result<void, WifiError> => {
@@ -197,12 +182,6 @@ const wifi: Wifi = {
   get country(): WifiCountryCode | undefined {
     return native.getCountry() as WifiCountryCode | undefined
   },
-
-  set country(cc: WifiCountryCode | undefined) {
-    if (cc !== undefined) {
-      native.setCountry(cc)
-    }
-  },
 }
 
 export {wifi}

package/src/mik_app_config.cpp

@@ -19,6 +19,7 @@ void MIK_DefaultConfig(MIKConfig* config) {
     config->fs_read_max = 0; /* 0 = runtime default (65536) */
     config->entry_point[0] = '\0';
     config->wifi_country[0] = '\0';
+    config->wifi_hostname[0] = '\0';
 }
 
 /* Minimal JSON parser for config file — avoids cJSON dependency.
@@ -343,8 +344,10 @@ int MIK_LoadConfig(const char* base_path, MIKConfig* config) {
             if (mik__json_get_number(buf, "fsReadMax", &num_val)) {
                 config->fs_read_max = (uint32_t)num_val;
             }
-            mik__json_get_string(buf, "wifiCountry", config->wifi_country,
+            mik__json_get_string(buf, "wifi.country", config->wifi_country,
                                  sizeof(config->wifi_country));
+            mik__json_get_string(buf, "wifi.hostname", config->wifi_hostname,
+                                 sizeof(config->wifi_hostname));
 
             platform->log(MIK_LOG_INFO, TAG,
                            "Loaded config: restart=%d delay=%dms stack=%u reserved=%lu",