react-native-local-network-info 1.0.0

package/build/LocalNetworkInfoModule.d.ts

@@ -0,0 +1,11 @@
+import { NativeModule } from 'expo';
+import { LocalNetworkInfoModuleEvents, LocalIpInfo, NetworkInterfaceInfo } from './LocalNetworkInfo.types';
+declare class LocalNetworkInfoModule extends NativeModule<LocalNetworkInfoModuleEvents> {
+    /** Capture the current local-IP/network-role snapshot. */
+    getLocalIpAsync(): Promise<LocalIpInfo>;
+    /** Enumerate all up, non-loopback IPv4 interfaces (for debugging/inspection). */
+    getAllInterfacesAsync(): Promise<NetworkInterfaceInfo[]>;
+}
+declare const _default: LocalNetworkInfoModule;
+export default _default;
+//# sourceMappingURL=LocalNetworkInfoModule.d.ts.map

package/build/LocalNetworkInfoModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalNetworkInfoModule.d.ts","sourceRoot":"","sources":["../src/LocalNetworkInfoModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAuB,MAAM,MAAM,CAAC;AAEzD,OAAO,EACL,4BAA4B,EAC5B,WAAW,EACX,oBAAoB,EACrB,MAAM,0BAA0B,CAAC;AAElC,OAAO,OAAO,sBAAuB,SAAQ,YAAY,CAAC,4BAA4B,CAAC;IACrF,0DAA0D;IAC1D,eAAe,IAAI,OAAO,CAAC,WAAW,CAAC;IACvC,iFAAiF;IACjF,qBAAqB,IAAI,OAAO,CAAC,oBAAoB,EAAE,CAAC;CACzD;;AAGD,wBAA+E"}

package/build/LocalNetworkInfoModule.js

@@ -0,0 +1,4 @@
+import { requireNativeModule } from 'expo';
+// The string must match `Name("LocalNetworkInfo")` in the Swift/Kotlin modules.
+export default requireNativeModule('LocalNetworkInfo');
+//# sourceMappingURL=LocalNetworkInfoModule.js.map

package/build/LocalNetworkInfoModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalNetworkInfoModule.js","sourceRoot":"","sources":["../src/LocalNetworkInfoModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,mBAAmB,EAAE,MAAM,MAAM,CAAC;AAezD,gFAAgF;AAChF,eAAe,mBAAmB,CAAyB,kBAAkB,CAAC,CAAC"}

package/build/LocalNetworkInfoModule.web.d.ts

@@ -0,0 +1,14 @@
+import { NativeModule } from 'expo';
+import { LocalNetworkInfoModuleEvents, LocalIpInfo, NetworkInterfaceInfo } from './LocalNetworkInfo.types';
+/**
+ * Web fallback. Browsers do not expose the device's local LAN IPv4, so this
+ * reports `role: 'none'` with a `null` IP. It exists so the package imports
+ * cleanly on web (Metro resolves `*.web.ts`) and the API surface stays stable.
+ */
+declare class LocalNetworkInfoModule extends NativeModule<LocalNetworkInfoModuleEvents> {
+    getLocalIpAsync(): Promise<LocalIpInfo>;
+    getAllInterfacesAsync(): Promise<NetworkInterfaceInfo[]>;
+}
+declare const _default: typeof LocalNetworkInfoModule;
+export default _default;
+//# sourceMappingURL=LocalNetworkInfoModule.web.d.ts.map

package/build/LocalNetworkInfoModule.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalNetworkInfoModule.web.d.ts","sourceRoot":"","sources":["../src/LocalNetworkInfoModule.web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,YAAY,EAAE,MAAM,MAAM,CAAC;AAEvD,OAAO,EACL,4BAA4B,EAC5B,WAAW,EACX,oBAAoB,EACrB,MAAM,0BAA0B,CAAC;AAElC;;;;GAIG;AACH,cAAM,sBAAuB,SAAQ,YAAY,CAAC,4BAA4B,CAAC;IACvE,eAAe,IAAI,OAAO,CAAC,WAAW,CAAC;IAevC,qBAAqB,IAAI,OAAO,CAAC,oBAAoB,EAAE,CAAC;CAG/D;;AAED,wBAAmF"}

package/build/LocalNetworkInfoModule.web.js

@@ -0,0 +1,27 @@
+import { registerWebModule, NativeModule } from 'expo';
+/**
+ * Web fallback. Browsers do not expose the device's local LAN IPv4, so this
+ * reports `role: 'none'` with a `null` IP. It exists so the package imports
+ * cleanly on web (Metro resolves `*.web.ts`) and the API surface stays stable.
+ */
+class LocalNetworkInfoModule extends NativeModule {
+    async getLocalIpAsync() {
+        return {
+            ip: null,
+            role: 'none',
+            isWifiConnected: false,
+            isHotspotHost: false,
+            interfaceName: null,
+            netmask: null,
+            gateway: null,
+            predictedClientRange: null,
+            platform: 'web',
+            timestamp: Date.now(),
+        };
+    }
+    async getAllInterfacesAsync() {
+        return [];
+    }
+}
+export default registerWebModule(LocalNetworkInfoModule, 'LocalNetworkInfoModule');
+//# sourceMappingURL=LocalNetworkInfoModule.web.js.map

package/build/LocalNetworkInfoModule.web.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LocalNetworkInfoModule.web.js","sourceRoot":"","sources":["../src/LocalNetworkInfoModule.web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAQvD;;;;GAIG;AACH,MAAM,sBAAuB,SAAQ,YAA0C;IAC7E,KAAK,CAAC,eAAe;QACnB,OAAO;YACL,EAAE,EAAE,IAAI;YACR,IAAI,EAAE,MAAM;YACZ,eAAe,EAAE,KAAK;YACtB,aAAa,EAAE,KAAK;YACpB,aAAa,EAAE,IAAI;YACnB,OAAO,EAAE,IAAI;YACb,OAAO,EAAE,IAAI;YACb,oBAAoB,EAAE,IAAI;YAC1B,QAAQ,EAAE,KAAK;YACf,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;SACtB,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,qBAAqB;QACzB,OAAO,EAAE,CAAC;IACZ,CAAC;CACF;AAED,eAAe,iBAAiB,CAAC,sBAAsB,EAAE,wBAAwB,CAAC,CAAC"}

package/build/index.d.ts

@@ -0,0 +1,43 @@
+import { EventSubscription } from 'expo-modules-core';
+import { LocalIpInfo, NetworkInterfaceInfo } from './LocalNetworkInfo.types';
+/**
+ * Capture the device's current local-IP / network-role snapshot.
+ *
+ * Resolves with WiFi-station info when connected to WiFi; otherwise hotspot-host
+ * info when the device is sharing its connection; otherwise `role: 'none'`.
+ *
+ * @example
+ * ```ts
+ * const info = await getLocalIp();
+ * if (info.role === 'wifi') console.log('On WiFi at', info.ip);
+ * if (info.role === 'hotspot') console.log('Hotspot host at', info.ip);
+ * ```
+ */
+export declare function getLocalIp(): Promise<LocalIpInfo>;
+/**
+ * Enumerate every up, non-loopback IPv4 interface with a best-effort role
+ * classification. Useful for debugging odd devices/vendors.
+ */
+export declare function getAllInterfaces(): Promise<NetworkInterfaceInfo[]>;
+/**
+ * Subscribe to network changes. The listener fires with a fresh
+ * {@link LocalIpInfo} whenever connectivity, WiFi, or hotspot state changes.
+ *
+ * Remember to call `.remove()` on the returned subscription to avoid leaks
+ * (or use {@link useLocalIp}, which manages this for you).
+ *
+ * @example
+ * ```ts
+ * const sub = addNetworkChangeListener((info) => {
+ *   console.log('network changed →', info.role, info.ip);
+ * });
+ * // later
+ * sub.remove();
+ * ```
+ */
+export declare function addNetworkChangeListener(listener: (info: LocalIpInfo) => void): EventSubscription;
+/** The raw native module instance (advanced use). */
+export { default as LocalNetworkInfoModule } from './LocalNetworkInfoModule';
+export { useLocalIp } from './useLocalIp';
+export * from './LocalNetworkInfo.types';
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAGtD,OAAO,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAE7E;;;;;;;;;;;;GAYG;AACH,wBAAsB,UAAU,IAAI,OAAO,CAAC,WAAW,CAAC,CAEvD;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAExE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,GACpC,iBAAiB,CAEnB;AAED,qDAAqD;AACrD,OAAO,EAAE,OAAO,IAAI,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAE7E,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,cAAc,0BAA0B,CAAC"}

package/build/index.js

@@ -0,0 +1,48 @@
+import LocalNetworkInfoModule from './LocalNetworkInfoModule';
+/**
+ * Capture the device's current local-IP / network-role snapshot.
+ *
+ * Resolves with WiFi-station info when connected to WiFi; otherwise hotspot-host
+ * info when the device is sharing its connection; otherwise `role: 'none'`.
+ *
+ * @example
+ * ```ts
+ * const info = await getLocalIp();
+ * if (info.role === 'wifi') console.log('On WiFi at', info.ip);
+ * if (info.role === 'hotspot') console.log('Hotspot host at', info.ip);
+ * ```
+ */
+export async function getLocalIp() {
+    return LocalNetworkInfoModule.getLocalIpAsync();
+}
+/**
+ * Enumerate every up, non-loopback IPv4 interface with a best-effort role
+ * classification. Useful for debugging odd devices/vendors.
+ */
+export async function getAllInterfaces() {
+    return LocalNetworkInfoModule.getAllInterfacesAsync();
+}
+/**
+ * Subscribe to network changes. The listener fires with a fresh
+ * {@link LocalIpInfo} whenever connectivity, WiFi, or hotspot state changes.
+ *
+ * Remember to call `.remove()` on the returned subscription to avoid leaks
+ * (or use {@link useLocalIp}, which manages this for you).
+ *
+ * @example
+ * ```ts
+ * const sub = addNetworkChangeListener((info) => {
+ *   console.log('network changed →', info.role, info.ip);
+ * });
+ * // later
+ * sub.remove();
+ * ```
+ */
+export function addNetworkChangeListener(listener) {
+    return LocalNetworkInfoModule.addListener('onNetworkChange', listener);
+}
+/** The raw native module instance (advanced use). */
+export { default as LocalNetworkInfoModule } from './LocalNetworkInfoModule';
+export { useLocalIp } from './useLocalIp';
+export * from './LocalNetworkInfo.types';
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,sBAAsB,MAAM,0BAA0B,CAAC;AAG9D;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU;IAC9B,OAAO,sBAAsB,CAAC,eAAe,EAAE,CAAC;AAClD,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB;IACpC,OAAO,sBAAsB,CAAC,qBAAqB,EAAE,CAAC;AACxD,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,wBAAwB,CACtC,QAAqC;IAErC,OAAO,sBAAsB,CAAC,WAAW,CAAC,iBAAiB,EAAE,QAAQ,CAAC,CAAC;AACzE,CAAC;AAED,qDAAqD;AACrD,OAAO,EAAE,OAAO,IAAI,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAE7E,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,cAAc,0BAA0B,CAAC"}

package/build/useLocalIp.d.ts

@@ -0,0 +1,18 @@
+import { LocalIpInfo } from './LocalNetworkInfo.types';
+/**
+ * React hook that returns the latest {@link LocalIpInfo} and keeps it updated as
+ * the network changes.
+ *
+ * It captures an initial snapshot on mount and then subscribes to native
+ * `onNetworkChange` events, cleaning up the subscription on unmount.
+ *
+ * @returns the latest snapshot, or `null` until the first snapshot resolves.
+ *
+ * @example
+ * ```tsx
+ * const info = useLocalIp();
+ * return <Text>{info?.ip ?? 'detecting…'} ({info?.role})</Text>;
+ * ```
+ */
+export declare function useLocalIp(): LocalIpInfo | null;
+//# sourceMappingURL=useLocalIp.d.ts.map

package/build/useLocalIp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocalIp.d.ts","sourceRoot":"","sources":["../src/useLocalIp.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAEvD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,IAAI,WAAW,GAAG,IAAI,CA6B/C"}

package/build/useLocalIp.js

@@ -0,0 +1,43 @@
+import { useEffect, useState } from 'react';
+import LocalNetworkInfoModule from './LocalNetworkInfoModule';
+/**
+ * React hook that returns the latest {@link LocalIpInfo} and keeps it updated as
+ * the network changes.
+ *
+ * It captures an initial snapshot on mount and then subscribes to native
+ * `onNetworkChange` events, cleaning up the subscription on unmount.
+ *
+ * @returns the latest snapshot, or `null` until the first snapshot resolves.
+ *
+ * @example
+ * ```tsx
+ * const info = useLocalIp();
+ * return <Text>{info?.ip ?? 'detecting…'} ({info?.role})</Text>;
+ * ```
+ */
+export function useLocalIp() {
+    const [info, setInfo] = useState(null);
+    useEffect(() => {
+        let mounted = true;
+        LocalNetworkInfoModule.getLocalIpAsync()
+            .then((snapshot) => {
+            if (mounted) {
+                setInfo(snapshot);
+            }
+        })
+            .catch(() => {
+            // Swallow — a change event or a later manual refresh will populate it.
+        });
+        const subscription = LocalNetworkInfoModule.addListener('onNetworkChange', (snapshot) => {
+            if (mounted) {
+                setInfo(snapshot);
+            }
+        });
+        return () => {
+            mounted = false;
+            subscription.remove();
+        };
+    }, []);
+    return info;
+}
+//# sourceMappingURL=useLocalIp.js.map

package/build/useLocalIp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocalIp.js","sourceRoot":"","sources":["../src/useLocalIp.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAE5C,OAAO,sBAAsB,MAAM,0BAA0B,CAAC;AAG9D;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,UAAU;IACxB,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,QAAQ,CAAqB,IAAI,CAAC,CAAC;IAE3D,SAAS,CAAC,GAAG,EAAE;QACb,IAAI,OAAO,GAAG,IAAI,CAAC;QAEnB,sBAAsB,CAAC,eAAe,EAAE;aACrC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE;YACjB,IAAI,OAAO,EAAE,CAAC;gBACZ,OAAO,CAAC,QAAQ,CAAC,CAAC;YACpB,CAAC;QACH,CAAC,CAAC;aACD,KAAK,CAAC,GAAG,EAAE;YACV,uEAAuE;QACzE,CAAC,CAAC,CAAC;QAEL,MAAM,YAAY,GAAG,sBAAsB,CAAC,WAAW,CAAC,iBAAiB,EAAE,CAAC,QAAQ,EAAE,EAAE;YACtF,IAAI,OAAO,EAAE,CAAC;gBACZ,OAAO,CAAC,QAAQ,CAAC,CAAC;YACpB,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,OAAO,GAAG,EAAE;YACV,OAAO,GAAG,KAAK,CAAC;YAChB,YAAY,CAAC,MAAM,EAAE,CAAC;QACxB,CAAC,CAAC;IACJ,CAAC,EAAE,EAAE,CAAC,CAAC;IAEP,OAAO,IAAI,CAAC;AACd,CAAC"}

package/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["apple", "android", "web"],
+  "apple": {
+    "modules": ["LocalNetworkInfoModule"]
+  },
+  "android": {
+    "modules": ["com.localnetworkinfo.LocalNetworkInfoModule"]
+  }
+}

package/ios/LocalNetworkInfo.podspec

@@ -0,0 +1,29 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'LocalNetworkInfo'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.platforms      = {
+    :ios => '15.1',
+    :tvos => '15.1'
+  }
+  s.swift_version  = '5.9'
+  s.source         = { git: 'https://github.com/daboss2003/react-native-local-network-info' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES'
+  }
+
+  s.source_files = "**/*.{h,m,mm,swift,hpp,cpp}"
+end

package/ios/LocalNetworkInfoModule.swift

@@ -0,0 +1,241 @@
+import ExpoModulesCore
+import Network
+
+public class LocalNetworkInfoModule: Module {
+  private var monitor: NWPathMonitor?
+  private let monitorQueue = DispatchQueue(label: "expo.modules.localnetworkinfo.monitor")
+
+  public func definition() -> ModuleDefinition {
+    Name("LocalNetworkInfo")
+
+    Events("onNetworkChange")
+
+    AsyncFunction("getLocalIpAsync") { () -> [String: Any?] in
+      return LocalNetworkInfoModule.buildInfo()
+    }
+
+    AsyncFunction("getAllInterfacesAsync") { () -> [[String: Any?]] in
+      return LocalNetworkInfoModule.enumerateInterfaces().map { $0.toDictionary() }
+    }
+
+    OnStartObserving {
+      self.startMonitoring()
+    }
+
+    OnStopObserving {
+      self.stopMonitoring()
+    }
+
+    OnDestroy {
+      self.stopMonitoring()
+    }
+  }
+
+  // MARK: - Network change monitoring
+
+  private func startMonitoring() {
+    guard monitor == nil else { return }
+    let pathMonitor = NWPathMonitor()
+    pathMonitor.pathUpdateHandler = { [weak self] _ in
+      self?.emitChange()
+    }
+    pathMonitor.start(queue: monitorQueue)
+    monitor = pathMonitor
+  }
+
+  private func stopMonitoring() {
+    monitor?.cancel()
+    monitor = nil
+  }
+
+  /// Emit an immediate snapshot, then re-sample shortly after: the hotspot
+  /// (`bridge100`) interface can receive its address a moment after the path
+  /// change fires, and no follow-up path event is guaranteed.
+  private func emitChange() {
+    sendEvent("onNetworkChange", LocalNetworkInfoModule.buildInfo())
+    for delay in [0.7, 1.8] {
+      monitorQueue.asyncAfter(deadline: .now() + delay) { [weak self] in
+        self?.sendEvent("onNetworkChange", LocalNetworkInfoModule.buildInfo())
+      }
+    }
+  }
+
+  // MARK: - Interface model
+
+  private enum Role: String {
+    case wifi
+    case hotspot
+    case cellular
+    case ethernet
+    case other
+  }
+
+  private struct Interface {
+    let name: String
+    let ipv4: String
+    let netmask: String
+    let role: Role
+
+    /// Reliable Personal Hotspot host fingerprint: iOS always assigns the host
+    /// 172.20.10.1 / 255.255.255.240 on a `bridge*` interface.
+    var isHotspotHost: Bool {
+      return name.hasPrefix("bridge")
+        && ipv4 == "172.20.10.1"
+        && netmask == "255.255.255.240"
+    }
+
+    func toDictionary() -> [String: Any?] {
+      return [
+        "name": name,
+        "ip": ipv4,
+        "netmask": netmask.isEmpty ? nil : netmask,
+        "role": role.rawValue,
+      ]
+    }
+  }
+
+  // MARK: - Detection
+
+  /// Classify an interface by its (de-facto, non-API) name. Heuristic, paired
+  /// with the 172.20.10.1 fingerprint for reliable hotspot-host detection.
+  private static func classify(_ name: String) -> Role {
+    if name.hasPrefix("bridge") { return .hotspot }   // bridge100 = Personal Hotspot host
+    if name == "en0" { return .wifi }                 // primary WiFi station
+    if name.hasPrefix("pdp_ip") { return .cellular }  // pdp_ip0 = cellular
+    if name.hasPrefix("en") { return .ethernet }      // en1/en2 = wired adapters
+    return .other                                     // awdl0, llw0, utun*, ap1, lo0, ...
+  }
+
+  /// Enumerate up, non-loopback IPv4 interfaces using getifaddrs(3).
+  private static func enumerateInterfaces() -> [Interface] {
+    var result: [Interface] = []
+
+    var ifaddrPtr: UnsafeMutablePointer<ifaddrs>?
+    guard getifaddrs(&ifaddrPtr) == 0, let first = ifaddrPtr else { return result }
+    defer { freeifaddrs(ifaddrPtr) }
+
+    for ptr in sequence(first: first, next: { $0.pointee.ifa_next }) {
+      let ifa = ptr.pointee
+
+      guard let addr = ifa.ifa_addr else { continue }
+      guard addr.pointee.sa_family == UInt8(AF_INET) else { continue }
+
+      let flags = Int32(ifa.ifa_flags)
+      guard (flags & IFF_UP) == IFF_UP, (flags & IFF_LOOPBACK) == 0 else { continue }
+
+      let name = String(cString: ifa.ifa_name)
+
+      // Use sa_len so the call is correct for AF_INET (16 bytes).
+      var hostBuffer = [CChar](repeating: 0, count: Int(NI_MAXHOST))
+      guard getnameinfo(addr, socklen_t(addr.pointee.sa_len),
+                        &hostBuffer, socklen_t(hostBuffer.count),
+                        nil, 0, NI_NUMERICHOST) == 0 else { continue }
+      let ip = String(cString: hostBuffer)
+
+      // Skip link-local AirDrop/Continuity addresses (awdl0/llw0 etc).
+      if ip.hasPrefix("169.254.") { continue }
+
+      var netmask = ""
+      if let nm = ifa.ifa_netmask {
+        var maskBuffer = [CChar](repeating: 0, count: Int(NI_MAXHOST))
+        if getnameinfo(nm, socklen_t(nm.pointee.sa_len),
+                       &maskBuffer, socklen_t(maskBuffer.count),
+                       nil, 0, NI_NUMERICHOST) == 0 {
+          netmask = String(cString: maskBuffer)
+        }
+      }
+
+      result.append(Interface(name: name, ipv4: ip, netmask: netmask, role: classify(name)))
+    }
+
+    return result
+  }
+
+  /// Build a `LocalIpInfo`-shaped dictionary, applying WiFi-over-hotspot precedence.
+  private static func buildInfo() -> [String: Any?] {
+    let interfaces = enumerateInterfaces()
+
+    let station = interfaces.first { $0.role == .wifi }
+    let host = interfaces.first { $0.isHotspotHost } ?? interfaces.first { $0.role == .hotspot }
+
+    let isWifiConnected = station != nil
+    let isHotspotHost = host != nil
+
+    var ip: String?
+    var role = "none"
+    var interfaceName: String?
+    var netmask: String?
+    var gateway: String?
+    var predicted: [String: String]?
+
+    if let station = station {
+      ip = station.ipv4
+      role = "wifi"
+      interfaceName = station.name
+      netmask = station.netmask.isEmpty ? nil : station.netmask
+      gateway = deriveGateway(ip: station.ipv4, netmask: station.netmask)
+    } else if let host = host {
+      ip = host.ipv4
+      role = "hotspot"
+      interfaceName = host.name
+      netmask = host.netmask.isEmpty ? nil : host.netmask
+      gateway = host.ipv4 // the hotspot host is its own gateway
+      predicted = predictClientRange(hostIp: host.ipv4, netmask: host.netmask)
+    }
+
+    return [
+      "ip": ip,
+      "role": role,
+      "isWifiConnected": isWifiConnected,
+      "isHotspotHost": isHotspotHost,
+      "interfaceName": interfaceName,
+      "netmask": netmask,
+      "gateway": gateway,
+      "predictedClientRange": predicted,
+      "platform": "ios",
+      "timestamp": Date().timeIntervalSince1970 * 1000,
+    ]
+  }
+
+  // MARK: - IPv4 math
+
+  private static func ipToInt(_ ip: String) -> UInt32? {
+    let parts = ip.split(separator: ".")
+    guard parts.count == 4 else { return nil }
+    var value: UInt32 = 0
+    for part in parts {
+      guard let octet = UInt32(part), octet <= 255 else { return nil }
+      value = (value << 8) | octet
+    }
+    return value
+  }
+
+  private static func intToIp(_ value: UInt32) -> String {
+    return "\((value >> 24) & 0xff).\((value >> 16) & 0xff).\((value >> 8) & 0xff).\(value & 0xff)"
+  }
+
+  /// Best-effort gateway guess for a station: the first host of the subnet.
+  /// iOS exposes no public default-gateway API, so this is a heuristic.
+  private static func deriveGateway(ip: String, netmask: String) -> String? {
+    guard let ipInt = ipToInt(ip), let maskInt = ipToInt(netmask), maskInt != 0 else { return nil }
+    let network = ipInt & maskInt
+    return intToIp(network + 1)
+  }
+
+  /// Predict the usable client IPv4 range of a hotspot subnet (network+1 ..
+  /// broadcast-1). The host occupies one address within this range unless it is
+  /// the first host, in which case the range starts at the next address.
+  private static func predictClientRange(hostIp: String, netmask: String) -> [String: String]? {
+    guard let ipInt = ipToInt(hostIp), let maskInt = ipToInt(netmask), maskInt != 0 else { return nil }
+    let network = ipInt & maskInt
+    let broadcast = network | ~maskInt
+    guard broadcast > network + 1 else { return nil } // needs at least 2 usable hosts
+
+    var first = network + 1
+    if first == ipInt { first += 1 } // skip the host itself
+    let last = broadcast - 1
+    guard last >= first else { return nil }
+
+    return ["first": intToIp(first), "last": intToIp(last)]
+  }
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "react-native-local-network-info",
+  "version": "1.0.0",
+  "description": "Read a React Native device's own local IPv4 address and whether it is connected to WiFi or acting as a hotspot host, with live network-change events. Built with the Expo Modules API; works in bare React Native and Expo.",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf build",
+    "prepare": "tsc",
+    "prepublishOnly": "tsc"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "expo-module",
+    "ip",
+    "local-ip",
+    "ipv4",
+    "network",
+    "wifi",
+    "hotspot",
+    "tethering",
+    "softap",
+    "gateway"
+  ],
+  "license": "MIT",
+  "author": "daboss2003",
+  "homepage": "https://github.com/daboss2003/react-native-local-network-info#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/daboss2003/react-native-local-network-info"
+  },
+  "files": [
+    "build",
+    "android",
+    "ios",
+    "src",
+    "expo-module.config.json",
+    "!android/build",
+    "!android/.gradle",
+    "!android/.cxx",
+    "!ios/build",
+    "!ios/Pods",
+    "!**/*.xcworkspace",
+    "!**/__tests__",
+    "!**/__mocks__"
+  ],
+  "peerDependencies": {
+    "expo": "*",
+    "react": "*",
+    "react-native": "*"
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.0",
+    "expo": "^56.0.0",
+    "react": "*",
+    "react-native": "*",
+    "typescript": "^5.9.0"
+  }
+}