@sigx/lynx-network 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Andreas Ekdahl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,55 @@
+# @sigx/lynx-network
+
+Network connectivity status for sigx-lynx. `NWPathMonitor` on iOS, `ConnectivityManager` on Android.
+
+## Install
+
+```bash
+pnpm add @sigx/lynx-network
+```
+
+```ts
+// sigx.lynx.config.ts
+export default defineLynxConfig({
+    modules: ['@sigx/lynx-network'],
+});
+```
+
+No special permissions on either platform.
+
+## Usage
+
+```ts
+import { Network } from '@sigx/lynx-network';
+
+const state = await Network.getState();
+if (state.isConnected && state.type === 'wifi') {
+    // sync large payload
+}
+```
+
+## API
+
+| Method                                | Notes                                                                                              |
+| ------------------------------------- | -------------------------------------------------------------------------------------------------- |
+| `getState(): Promise<NetworkState>`   | Single async snapshot — no subscription stream yet.                                                |
+| `isAvailable(): boolean`              | Whether the native module is registered in the current build.                                      |
+
+```ts
+type ConnectionType = 'wifi' | 'cellular' | 'ethernet' | 'bluetooth' | 'none' | 'unknown';
+
+interface NetworkState {
+    isConnected: boolean;
+    type: ConnectionType;
+    isInternetReachable: boolean | null;   // null = unknown (e.g. captive portal)
+}
+```
+
+## Gotchas
+
+- **`isInternetReachable: null`** means the OS hasn't confirmed actual reachability — common on captive-portal Wi-Fi (you're connected to an AP but can't reach the internet without sign-in). Treat as "probably yes".
+- **No subscription API yet.** If you need to react to connectivity changes live, poll `getState()` from a `setInterval` or wrap a small effect — the native publisher exists but isn't surfaced as JS events in this version.
+
+## Reference app
+
+`examples/lynx-one/my-sigx-app/src/cards/NetworkCard.tsx` renders the snapshot and refreshes on tap.

package/android/com/sigx/network/NetworkModule.kt

@@ -0,0 +1,67 @@
+package com.sigx.network
+
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.NetworkCapabilities
+import android.os.Build
+import android.util.Log
+import com.lynx.jsbridge.LynxMethod
+import com.lynx.jsbridge.LynxModule
+import com.lynx.react.bridge.Callback
+import com.lynx.react.bridge.JavaOnlyMap
+
+/**
+ * Network connectivity status module.
+ * JS usage: NativeModules.Network.getState(callback)
+ */
+class NetworkModule(context: Context) : LynxModule(context) {
+
+    companion object {
+        private const val TAG = "NetworkModule"
+    }
+
+    @LynxMethod
+    fun getState(callback: Callback?) {
+        try {
+            val cm = mContext.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+            val result = JavaOnlyMap()
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                val network = cm.activeNetwork
+                val capabilities = network?.let { cm.getNetworkCapabilities(it) }
+
+                if (capabilities != null) {
+                    result.putBoolean("isConnected", true)
+                    result.putBoolean("isInternetReachable",
+                        capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET))
+
+                    val type = when {
+                        capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) -> "wifi"
+                        capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR) -> "cellular"
+                        capabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET) -> "ethernet"
+                        capabilities.hasTransport(NetworkCapabilities.TRANSPORT_BLUETOOTH) -> "bluetooth"
+                        else -> "unknown"
+                    }
+                    result.putString("type", type)
+                } else {
+                    result.putBoolean("isConnected", false)
+                    result.putString("type", "none")
+                    result.putBoolean("isInternetReachable", false)
+                }
+            } else {
+                @Suppress("DEPRECATION")
+                val info = cm.activeNetworkInfo
+                result.putBoolean("isConnected", info?.isConnected == true)
+                result.putString("type", if (info?.isConnected == true) "unknown" else "none")
+                result.putBoolean("isInternetReachable", info?.isConnected == true)
+            }
+
+            callback?.invoke(result)
+        } catch (e: Exception) {
+            val error = JavaOnlyMap()
+            error.putString("error", e.message ?: "Unknown error")
+            callback?.invoke(error)
+        }
+    }
+}
+

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { Network } from './network.js';
+export type { ConnectionType, NetworkState } from './network.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { Network } from './network.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC"}

package/dist/network.d.ts

@@ -0,0 +1,22 @@
+export type ConnectionType = 'wifi' | 'cellular' | 'ethernet' | 'bluetooth' | 'none' | 'unknown';
+export interface NetworkState {
+    isConnected: boolean;
+    type: ConnectionType;
+    isInternetReachable: boolean | null;
+}
+/**
+ * Network connectivity APIs.
+ *
+ * @example
+ * ```ts
+ * import { Network } from '@sigx/lynx-network';
+ *
+ * const state = await Network.getState();
+ * console.log(state.isConnected, state.type);
+ * ```
+ */
+export declare const Network: {
+    readonly getState: () => Promise<NetworkState>;
+    readonly isAvailable: () => boolean;
+};
+//# sourceMappingURL=network.d.ts.map

package/dist/network.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network.d.ts","sourceRoot":"","sources":["../src/network.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,UAAU,GAAG,UAAU,GAAG,WAAW,GAAG,MAAM,GAAG,SAAS,CAAC;AAEjG,MAAM,WAAW,YAAY;IACzB,WAAW,EAAE,OAAO,CAAC;IACrB,IAAI,EAAE,cAAc,CAAC;IACrB,mBAAmB,EAAE,OAAO,GAAG,IAAI,CAAC;CACvC;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,OAAO;6BACJ,OAAO,CAAC,YAAY,CAAC;gCAIlB,OAAO;CAGhB,CAAC"}

package/dist/network.js

@@ -0,0 +1,22 @@
+import { callAsync, isModuleAvailable } from '@sigx/lynx-core';
+const MODULE = 'Network';
+/**
+ * Network connectivity APIs.
+ *
+ * @example
+ * ```ts
+ * import { Network } from '@sigx/lynx-network';
+ *
+ * const state = await Network.getState();
+ * console.log(state.isConnected, state.type);
+ * ```
+ */
+export const Network = {
+    getState() {
+        return callAsync(MODULE, 'getState');
+    },
+    isAvailable() {
+        return isModuleAvailable(MODULE);
+    },
+};
+//# sourceMappingURL=network.js.map

package/dist/network.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"network.js","sourceRoot":"","sources":["../src/network.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAE/D,MAAM,MAAM,GAAG,SAAS,CAAC;AAUzB;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,OAAO,GAAG;IACnB,QAAQ;QACJ,OAAO,SAAS,CAAe,MAAM,EAAE,UAAU,CAAC,CAAC;IACvD,CAAC;IAED,WAAW;QACP,OAAO,iBAAiB,CAAC,MAAM,CAAC,CAAC;IACrC,CAAC;CACK,CAAC"}

package/ios/NetworkModule.swift

@@ -0,0 +1,69 @@
+import Foundation
+import Network
+import Lynx
+
+/// Network connectivity status module.
+/// JS usage: NativeModules.Network.getState(callback)
+class NetworkModule: NSObject, LynxModule {
+
+    @objc static var name: String { "Network" }
+
+    @objc static var methodLookup: [String: String] {
+        [
+            "getState": NSStringFromSelector(#selector(getState(_:))),
+        ]
+    }
+
+    private let monitor = NWPathMonitor()
+    private let monitorQueue = DispatchQueue(label: "com.sigx.lynxgo.network-monitor")
+    private var currentPath: NWPath?
+
+    required override init() {
+        super.init()
+        startMonitor()
+    }
+
+    required init(param: Any) {
+        super.init()
+        startMonitor()
+    }
+
+    private func startMonitor() {
+        monitor.pathUpdateHandler = { [weak self] path in
+            self?.currentPath = path
+        }
+        monitor.start(queue: monitorQueue)
+    }
+
+    deinit {
+        monitor.cancel()
+    }
+
+    @objc func getState(_ callback: LynxCallbackBlock?) {
+        let path = currentPath ?? monitor.currentPath
+
+        let isConnected = path.status == .satisfied
+        let isExpensive = path.isExpensive
+
+        let type: String
+        if path.usesInterfaceType(.wifi) {
+            type = "wifi"
+        } else if path.usesInterfaceType(.cellular) {
+            type = "cellular"
+        } else if path.usesInterfaceType(.wiredEthernet) {
+            type = "ethernet"
+        } else if path.status == .satisfied {
+            type = "unknown"
+        } else {
+            type = "none"
+        }
+
+        let result: [String: Any] = [
+            "isConnected": isConnected,
+            "type": type,
+            "isInternetReachable": isConnected,
+            "isExpensive": isExpensive,
+        ]
+        callback?(result)
+    }
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@sigx/lynx-network",
+  "version": "0.1.0",
+  "description": "Network connectivity status for sigx-lynx",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./sigx-module.json": "./sigx-module.json"
+  },
+  "files": [
+    "dist",
+    "ios",
+    "android",
+    "sigx-module.json"
+  ],
+  "dependencies": {
+    "@sigx/lynx-core": "^0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  },
+  "author": "Andreas Ekdahl",
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  }
+}

package/sigx-module.json

@@ -0,0 +1,16 @@
+{
+    "name": "Network",
+    "package": "@sigx/lynx-network",
+    "description": "Network connectivity status",
+    "platforms": ["android", "ios"],
+    "ios": {
+        "moduleClass": "NetworkModule",
+        "sourceDir": "ios",
+        "methods": ["getState"]
+    },
+    "android": {
+        "moduleClass": "com.sigx.network.NetworkModule",
+        "sourceDir": "android",
+        "permissions": []
+    }
+}