@symbiote-native/network 0.0.1

package/build-ngc/core/network.d.ts

@@ -0,0 +1,13 @@
+import { type EventSubscription } from 'expo-modules-core';
+import type { NetworkState, NetworkStateEvent } from './types';
+/** Gets the device's current network connection state. */
+export declare function getNetworkStateAsync(): Promise<NetworkState>;
+/** Gets the device's current IPv4 address. Returns `"0.0.0.0"` if it could not be retrieved. */
+export declare function getIpAddressAsync(): Promise<string>;
+/**
+ * Tells if the device is in airplane mode.
+ * @platform android
+ */
+export declare function isAirplaneModeEnabledAsync(): Promise<boolean>;
+/** Subscribe to network state changes (connection type, connected, internet reachable). */
+export declare function addNetworkStateListener(listener: (event: NetworkStateEvent) => void): EventSubscription;

package/build-ngc/core/network.js

@@ -0,0 +1,35 @@
+// Hand-ported from .vendors/expo/packages/expo-network/src/Network.ts (sdk-57). Unlike
+// battery, upstream Network throws UnavailabilityError when the native method is absent —
+// same convention as packages/haptics/src/core/haptics.ts.
+import { UnavailabilityError } from 'expo-modules-core';
+import { expoNetwork } from './native-module';
+const NATIVE_MODULE_NAME = 'expo-network';
+/** Gets the device's current network connection state. */
+export async function getNetworkStateAsync() {
+    if (!expoNetwork.getNetworkStateAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getNetworkStateAsync');
+    }
+    return expoNetwork.getNetworkStateAsync();
+}
+/** Gets the device's current IPv4 address. Returns `"0.0.0.0"` if it could not be retrieved. */
+export async function getIpAddressAsync() {
+    if (!expoNetwork.getIpAddressAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getIpAddressAsync');
+    }
+    return expoNetwork.getIpAddressAsync();
+}
+/**
+ * Tells if the device is in airplane mode.
+ * @platform android
+ */
+export async function isAirplaneModeEnabledAsync() {
+    if (!expoNetwork.isAirplaneModeEnabledAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'isAirplaneModeEnabledAsync');
+    }
+    return expoNetwork.isAirplaneModeEnabledAsync();
+}
+/** Subscribe to network state changes (connection type, connected, internet reachable). */
+export function addNetworkStateListener(listener) {
+    return expoNetwork.addListener('onNetworkStateChanged', listener);
+}
+//# sourceMappingURL=network.js.map

package/build-ngc/core/network.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"network.js","sourceRoot":"","sources":["../../src/core/network.ts"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,0FAA0F;AAC1F,2DAA2D;AAC3D,OAAO,EAAE,mBAAmB,EAA0B,MAAM,mBAAmB,CAAC;AAChF,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAG9C,MAAM,kBAAkB,GAAG,cAAc,CAAC;AAE1C,0DAA0D;AAC1D,MAAM,CAAC,KAAK,UAAU,oBAAoB;IACxC,IAAI,CAAC,WAAW,CAAC,oBAAoB,EAAE,CAAC;QACtC,MAAM,IAAI,mBAAmB,CAAC,kBAAkB,EAAE,sBAAsB,CAAC,CAAC;IAC5E,CAAC;IACD,OAAO,WAAW,CAAC,oBAAoB,EAAE,CAAC;AAC5C,CAAC;AAED,gGAAgG;AAChG,MAAM,CAAC,KAAK,UAAU,iBAAiB;IACrC,IAAI,CAAC,WAAW,CAAC,iBAAiB,EAAE,CAAC;QACnC,MAAM,IAAI,mBAAmB,CAAC,kBAAkB,EAAE,mBAAmB,CAAC,CAAC;IACzE,CAAC;IACD,OAAO,WAAW,CAAC,iBAAiB,EAAE,CAAC;AACzC,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,0BAA0B;IAC9C,IAAI,CAAC,WAAW,CAAC,0BAA0B,EAAE,CAAC;QAC5C,MAAM,IAAI,mBAAmB,CAAC,kBAAkB,EAAE,4BAA4B,CAAC,CAAC;IAClF,CAAC;IACD,OAAO,WAAW,CAAC,0BAA0B,EAAE,CAAC;AAClD,CAAC;AAED,2FAA2F;AAC3F,MAAM,UAAU,uBAAuB,CACrC,QAA4C;IAE5C,OAAO,WAAW,CAAC,WAAW,CAAC,uBAAuB,EAAE,QAAQ,CAAC,CAAC;AACpE,CAAC"}

package/build-ngc/core/types.d.ts

@@ -0,0 +1,55 @@
+export declare enum NetworkStateType {
+    /** No active network connection detected. */
+    NONE = "NONE",
+    /** The connection type could not be determined. */
+    UNKNOWN = "UNKNOWN",
+    /** Active network connection over mobile data.
+     * @platform android
+     * @platform ios
+     */
+    CELLULAR = "CELLULAR",
+    /** Active network connection over Wi-Fi.
+     * @platform android
+     * @platform ios
+     */
+    WIFI = "WIFI",
+    /** Active network connection over Bluetooth.
+     * @platform android
+     */
+    BLUETOOTH = "BLUETOOTH",
+    /** Active network connection over Ethernet.
+     * @platform android
+     * @platform ios
+     */
+    ETHERNET = "ETHERNET",
+    /** Active network connection over WiMAX.
+     * @platform android
+     */
+    WIMAX = "WIMAX",
+    /** Active network connection over VPN.
+     * @platform android
+     */
+    VPN = "VPN",
+    /** Active network connection over other network connection types.
+     * @platform android
+     */
+    OTHER = "OTHER"
+}
+export type NetworkState = {
+    /** The current network connection type. */
+    type?: NetworkStateType;
+    /**
+     * If there is an active network connection. Note that this does not mean internet is
+     * reachable. `false` when `type` is `NONE` or `UNKNOWN`, `true` otherwise.
+     */
+    isConnected?: boolean;
+    /**
+     * If the internet is reachable with the currently active network connection. On Android this
+     * requires internet capability, confirmed internet access, and a usable connection state; VPN
+     * connections also require non-zero downstream bandwidth. On iOS this always matches
+     * `isConnected`.
+     */
+    isInternetReachable?: boolean;
+};
+/** Passed as the argument to listeners registered with `addNetworkStateListener()`. */
+export type NetworkStateEvent = NetworkState;

package/build-ngc/core/types.js

@@ -0,0 +1,41 @@
+// Hand-ported from .vendors/expo/packages/expo-network/src/Network.types.ts (sdk-57) — plain
+// data shapes, no `expo` meta-package import to swap out (unlike local-auth's types.ts).
+export var NetworkStateType;
+(function (NetworkStateType) {
+    /** No active network connection detected. */
+    NetworkStateType["NONE"] = "NONE";
+    /** The connection type could not be determined. */
+    NetworkStateType["UNKNOWN"] = "UNKNOWN";
+    /** Active network connection over mobile data.
+     * @platform android
+     * @platform ios
+     */
+    NetworkStateType["CELLULAR"] = "CELLULAR";
+    /** Active network connection over Wi-Fi.
+     * @platform android
+     * @platform ios
+     */
+    NetworkStateType["WIFI"] = "WIFI";
+    /** Active network connection over Bluetooth.
+     * @platform android
+     */
+    NetworkStateType["BLUETOOTH"] = "BLUETOOTH";
+    /** Active network connection over Ethernet.
+     * @platform android
+     * @platform ios
+     */
+    NetworkStateType["ETHERNET"] = "ETHERNET";
+    /** Active network connection over WiMAX.
+     * @platform android
+     */
+    NetworkStateType["WIMAX"] = "WIMAX";
+    /** Active network connection over VPN.
+     * @platform android
+     */
+    NetworkStateType["VPN"] = "VPN";
+    /** Active network connection over other network connection types.
+     * @platform android
+     */
+    NetworkStateType["OTHER"] = "OTHER";
+})(NetworkStateType || (NetworkStateType = {}));
+//# sourceMappingURL=types.js.map

package/build-ngc/core/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"AAAA,6FAA6F;AAC7F,yFAAyF;AAEzF,MAAM,CAAN,IAAY,gBAoCX;AApCD,WAAY,gBAAgB;IAC1B,6CAA6C;IAC7C,iCAAa,CAAA;IACb,mDAAmD;IACnD,uCAAmB,CAAA;IACnB;;;OAGG;IACH,yCAAqB,CAAA;IACrB;;;OAGG;IACH,iCAAa,CAAA;IACb;;OAEG;IACH,2CAAuB,CAAA;IACvB;;;OAGG;IACH,yCAAqB,CAAA;IACrB;;OAEG;IACH,mCAAe,CAAA;IACf;;OAEG;IACH,+BAAW,CAAA;IACX;;OAEG;IACH,mCAAe,CAAA;AACjB,CAAC,EApCW,gBAAgB,KAAhB,gBAAgB,QAoC3B"}

package/native-link.json

@@ -0,0 +1,12 @@
+{
+  "android": {
+    "gradleProjectName": "expo-network",
+    "modules": [
+      {
+        "importPath": "expo.modules.network.NetworkModule",
+        "className": "NetworkModule",
+        "nativeName": "ExpoNetwork"
+      }
+    ]
+  }
+}

package/package.json

@@ -0,0 +1,107 @@
+{
+  "name": "@symbiote-native/network",
+  "version": "0.0.1",
+  "description": "expo-network wrapped for SymbioteNative — one framework-agnostic core, built once and reachable from the React, Vue, and Angular adapters. Network state (type/connected/internet-reachable) with a change listener, device IP address, and airplane-mode detection.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OneEyed1366/symbiote-native.git",
+    "directory": "packages/network"
+  },
+  "homepage": "https://github.com/OneEyed1366/symbiote-native/tree/master/packages/network#readme",
+  "bugs": {
+    "url": "https://github.com/OneEyed1366/symbiote-native/issues"
+  },
+  "author": "Andrey Prokopenko <psevdoproger@gmail.com>",
+  "type": "module",
+  "main": "./build/core/index.js",
+  "module": "./build/core/index.js",
+  "types": "./build/core/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/core/index.d.ts",
+      "default": "./build/core/index.js"
+    },
+    "./vue": {
+      "types": "./build/vue/index.d.ts",
+      "default": "./build/vue/index.js"
+    },
+    "./react": {
+      "types": "./build/react/index.d.ts",
+      "default": "./build/react/index.js"
+    },
+    "./angular": {
+      "types": "./build-ngc/angular/index.d.ts",
+      "react-native": "./build-ngc/angular/index.js",
+      "default": "./src/angular/index.ts"
+    }
+  },
+  "files": [
+    "src",
+    "build",
+    "build-ngc",
+    "native-link.json"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "expo-network": "57.0.1",
+    "expo-modules-core": "57.0.5"
+  },
+  "peerDependencies": {
+    "@symbiote-native/engine": ">=0.1.7",
+    "@angular/core": ">=20",
+    "@vue/runtime-core": "^3.5.13",
+    "react": ">=19.0.0",
+    "react-native": ">=0.86",
+    "vue": ">=3.5.0",
+    "@symbiote-native/angular": "0.6.1",
+    "@symbiote-native/react": "0.2.8",
+    "@symbiote-native/vue": "0.3.8"
+  },
+  "peerDependenciesMeta": {
+    "@symbiote-native/angular": {
+      "optional": true
+    },
+    "@symbiote-native/react": {
+      "optional": true
+    },
+    "@symbiote-native/vue": {
+      "optional": true
+    },
+    "@angular/core": {
+      "optional": true
+    },
+    "@vue/runtime-core": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@angular/compiler": "^22",
+    "@angular/compiler-cli": "^22",
+    "@angular/core": "^22",
+    "@types/node": "^26.0.0",
+    "@types/react": "^19.2.0",
+    "@vue/runtime-core": "^3.5.13",
+    "react": "19.2.3",
+    "typescript": "~6.0.0",
+    "@symbiote-native/angular": "0.6.1",
+    "@symbiote-native/react": "0.2.8",
+    "@symbiote-native/engine": "0.1.7",
+    "@symbiote-native/vue": "0.3.8",
+    "@symbiote-native/test-utils": "0.1.6"
+  },
+  "scripts": {
+    "typecheck": "tsc --build",
+    "clean": "rm -rf build-ngc",
+    "ng:build": "pnpm run clean && ngc -p tsconfig.angular.json",
+    "format": "prettier --write \"src/**/*.{ts,tsx}\""
+  }
+}

package/src/angular/index.ts

@@ -0,0 +1,13 @@
+// NetworkStateService is the Angular-only lifecycle half; the free functions and event
+// subscription plumbing all live in core, shared with React/Vue.
+export { NetworkStateService } from './services/network-state.service';
+export {
+  getNetworkStateAsync,
+  getIpAddressAsync,
+  isAirplaneModeEnabledAsync,
+  addNetworkStateListener,
+  NetworkStateType,
+  type NetworkState,
+  type NetworkStateEvent,
+  type EventSubscription,
+} from '../core';

package/src/angular/services/network-state.service/index.ts

@@ -0,0 +1,26 @@
+import { effect, inject, Injectable, Injector, signal, type Signal } from '@angular/core';
+import { addNetworkStateListener, getNetworkStateAsync, type NetworkState } from '../../../core';
+
+// Angular twin of React's `useNetworkState` hook and Vue's `useNetworkState` composable.
+//
+//   readonly networkState = inject(NetworkStateService).connect();
+//   // template: {{ networkState().type }}
+@Injectable({ providedIn: 'root' })
+export class NetworkStateService {
+  private readonly injector = inject(Injector);
+
+  connect(): Signal<NetworkState> {
+    const networkState = signal<NetworkState>({});
+
+    effect(
+      onCleanup => {
+        getNetworkStateAsync().then(state => networkState.set(state));
+        const subscription = addNetworkStateListener(event => networkState.set(event));
+        onCleanup(() => subscription.remove());
+      },
+      { injector: this.injector },
+    );
+
+    return networkState.asReadonly();
+  }
+}

package/src/angular/services/network-state.service/network-state.service.test.ts

@@ -0,0 +1,103 @@
+// Co-located Angular-driven test (ADR 0025) for NetworkStateService. See battery's
+// battery-state.service.test.ts for the shared rationale.
+
+import '@angular/compiler';
+import { Component, inject, type Signal } from '@angular/core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mount, unmount } from '@symbiote-native/angular';
+import { installFabric } from '@symbiote-native/test-utils';
+import { NetworkStateService } from './index';
+
+type INetworkState = { type?: string; isConnected?: boolean; isInternetReachable?: boolean };
+
+const addListenerMock = vi.fn();
+const removeMock = vi.fn();
+const getNetworkStateAsyncMock = vi.fn(async () => ({
+  type: 'WIFI',
+  isConnected: true,
+  isInternetReachable: true,
+}));
+
+vi.mock('../../../core', () => ({
+  addNetworkStateListener: (listener: (event: INetworkState) => void) => addListenerMock(listener),
+  getNetworkStateAsync: () => getNetworkStateAsyncMock(),
+}));
+
+const ROOT_TAG = 973;
+const fabric = installFabric();
+const tick = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 0));
+
+let capturedResult: Signal<INetworkState> | undefined;
+let capturedListener: ((event: INetworkState) => void) | undefined;
+
+@Component({
+  selector: 'symbiote-network-state-host',
+  standalone: true,
+  template: '',
+})
+class NetworkStateHost {
+  readonly networkState = inject(NetworkStateService).connect();
+
+  constructor() {
+    capturedResult = this.networkState;
+  }
+}
+
+beforeEach(() => {
+  capturedResult = undefined;
+  capturedListener = undefined;
+  getNetworkStateAsyncMock.mockResolvedValue({
+    type: 'WIFI',
+    isConnected: true,
+    isInternetReachable: true,
+  });
+  addListenerMock.mockImplementation(listener => {
+    capturedListener = listener;
+    return { remove: removeMock };
+  });
+});
+
+afterEach(() => {
+  unmount(ROOT_TAG);
+  fabric.reset();
+  vi.clearAllMocks();
+});
+
+describe('NetworkStateService.connect', () => {
+  it('reports an empty object before the initial fetch resolves', async () => {
+    mount(ROOT_TAG, NetworkStateHost);
+
+    expect(capturedResult?.()).toEqual({});
+  });
+
+  it('reports the fetched state once getNetworkStateAsync() resolves', async () => {
+    mount(ROOT_TAG, NetworkStateHost);
+    await tick();
+
+    expect(capturedResult?.()).toEqual({
+      type: 'WIFI',
+      isConnected: true,
+      isInternetReachable: true,
+    });
+  });
+
+  it('updates the signal when the registered listener fires', async () => {
+    mount(ROOT_TAG, NetworkStateHost);
+    await tick();
+
+    if (capturedListener === undefined) throw new Error('addListener callback was not captured');
+    capturedListener({ type: 'CELLULAR', isConnected: true, isInternetReachable: false });
+
+    expect(capturedResult?.()?.type).toBe('CELLULAR');
+  });
+
+  it('removes the subscription when the host component is unmounted', async () => {
+    mount(ROOT_TAG, NetworkStateHost);
+    await tick();
+
+    unmount(ROOT_TAG);
+    await tick();
+
+    expect(removeMock).toHaveBeenCalledOnce();
+  });
+});

package/src/core/index.ts

@@ -0,0 +1,8 @@
+export {
+  getNetworkStateAsync,
+  getIpAddressAsync,
+  isAirplaneModeEnabledAsync,
+  addNetworkStateListener,
+} from './network';
+export { NetworkStateType, type NetworkState, type NetworkStateEvent } from './types';
+export type { EventSubscription } from 'expo-modules-core';

package/src/core/native-module.ts

@@ -0,0 +1,19 @@
+import { requireNativeModule } from 'expo-modules-core';
+import type { EventSubscription } from 'expo-modules-core';
+import type { NetworkStateEvent } from './types';
+
+const EXPO_NETWORK_MODULE_NAME = 'ExpoNetwork';
+
+// Upstream's own event name, verified against .vendors/expo/packages/expo-network/src/Network.ts
+// (sdk-57) — bare `onNetworkStateChanged`, unlike haptics/battery's `Expo.xxx`-namespaced names.
+export type INativeNetworkModule = {
+  getNetworkStateAsync?(): Promise<NetworkStateEvent>;
+  getIpAddressAsync?(): Promise<string>;
+  isAirplaneModeEnabledAsync?(): Promise<boolean>;
+  addListener(
+    eventName: 'onNetworkStateChanged',
+    listener: (event: NetworkStateEvent) => void,
+  ): EventSubscription;
+};
+
+export const expoNetwork = requireNativeModule<INativeNetworkModule>(EXPO_NETWORK_MODULE_NAME);

package/src/core/network.test.ts

@@ -0,0 +1,103 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const FAKE_NATIVE_NETWORK = {
+  getNetworkStateAsync: vi.fn(async () => ({
+    type: 'WIFI',
+    isConnected: true,
+    isInternetReachable: true,
+  })),
+  getIpAddressAsync: vi.fn(async () => '192.168.1.1'),
+  isAirplaneModeEnabledAsync: vi.fn(async () => false),
+  addListener: vi.fn(() => ({ remove: vi.fn() })),
+};
+
+// The real ExpoNetwork native module only exists on device — resolving it via
+// requireNativeModule() at import time would throw in this headless test run, so the
+// module-lookup file is faked in place of expo-modules-core's runtime resolution, same pattern
+// packages/battery/src/core/battery.test.ts uses for its native-module.
+vi.mock('./native-module', () => ({
+  expoNetwork: FAKE_NATIVE_NETWORK,
+}));
+
+// expo-modules-core's real entry transitively imports 'react-native' for Platform/
+// TurboModuleRegistry, whose Flow-typed source Vitest's Oxc transform can't parse — same fake
+// packages/haptics/src/core/haptics.test.ts uses.
+vi.mock('expo-modules-core', () => ({
+  UnavailabilityError: class UnavailabilityError extends Error {
+    constructor(moduleName: string, propertyName: string) {
+      super(`${propertyName} is not available on ${moduleName}`);
+    }
+  },
+}));
+
+const {
+  getNetworkStateAsync,
+  getIpAddressAsync,
+  isAirplaneModeEnabledAsync,
+  addNetworkStateListener,
+} = await import('./network');
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+describe('getNetworkStateAsync', () => {
+  it('delegates to the native module', async () => {
+    await expect(getNetworkStateAsync()).resolves.toEqual({
+      type: 'WIFI',
+      isConnected: true,
+      isInternetReachable: true,
+    });
+  });
+
+  it('throws UnavailabilityError when the native method is absent', async () => {
+    const { getNetworkStateAsync: native } = FAKE_NATIVE_NETWORK;
+    // @ts-expect-error -- simulating a platform where the native module has no such method
+    FAKE_NATIVE_NETWORK.getNetworkStateAsync = undefined;
+
+    await expect(getNetworkStateAsync()).rejects.toThrow();
+
+    FAKE_NATIVE_NETWORK.getNetworkStateAsync = native;
+  });
+});
+
+describe('getIpAddressAsync', () => {
+  it('delegates to the native module', async () => {
+    await expect(getIpAddressAsync()).resolves.toBe('192.168.1.1');
+  });
+
+  it('throws UnavailabilityError when the native method is absent', async () => {
+    const { getIpAddressAsync: native } = FAKE_NATIVE_NETWORK;
+    // @ts-expect-error -- simulating a platform where the native module has no such method
+    FAKE_NATIVE_NETWORK.getIpAddressAsync = undefined;
+
+    await expect(getIpAddressAsync()).rejects.toThrow();
+
+    FAKE_NATIVE_NETWORK.getIpAddressAsync = native;
+  });
+});
+
+describe('isAirplaneModeEnabledAsync', () => {
+  it('delegates to the native module', async () => {
+    await expect(isAirplaneModeEnabledAsync()).resolves.toBe(false);
+  });
+
+  it('throws UnavailabilityError when the native method is absent', async () => {
+    const { isAirplaneModeEnabledAsync: native } = FAKE_NATIVE_NETWORK;
+    // @ts-expect-error -- simulating a platform where the native module has no such method
+    FAKE_NATIVE_NETWORK.isAirplaneModeEnabledAsync = undefined;
+
+    await expect(isAirplaneModeEnabledAsync()).rejects.toThrow();
+
+    FAKE_NATIVE_NETWORK.isAirplaneModeEnabledAsync = native;
+  });
+});
+
+describe('addNetworkStateListener', () => {
+  it('subscribes through the onNetworkStateChanged event name', () => {
+    const listener = vi.fn();
+    addNetworkStateListener(listener);
+
+    expect(FAKE_NATIVE_NETWORK.addListener).toHaveBeenCalledWith('onNetworkStateChanged', listener);
+  });
+});

package/src/core/network.ts

@@ -0,0 +1,42 @@
+// Hand-ported from .vendors/expo/packages/expo-network/src/Network.ts (sdk-57). Unlike
+// battery, upstream Network throws UnavailabilityError when the native method is absent —
+// same convention as packages/haptics/src/core/haptics.ts.
+import { UnavailabilityError, type EventSubscription } from 'expo-modules-core';
+import { expoNetwork } from './native-module';
+import type { NetworkState, NetworkStateEvent } from './types';
+
+const NATIVE_MODULE_NAME = 'expo-network';
+
+/** Gets the device's current network connection state. */
+export async function getNetworkStateAsync(): Promise<NetworkState> {
+  if (!expoNetwork.getNetworkStateAsync) {
+    throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getNetworkStateAsync');
+  }
+  return expoNetwork.getNetworkStateAsync();
+}
+
+/** Gets the device's current IPv4 address. Returns `"0.0.0.0"` if it could not be retrieved. */
+export async function getIpAddressAsync(): Promise<string> {
+  if (!expoNetwork.getIpAddressAsync) {
+    throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getIpAddressAsync');
+  }
+  return expoNetwork.getIpAddressAsync();
+}
+
+/**
+ * Tells if the device is in airplane mode.
+ * @platform android
+ */
+export async function isAirplaneModeEnabledAsync(): Promise<boolean> {
+  if (!expoNetwork.isAirplaneModeEnabledAsync) {
+    throw new UnavailabilityError(NATIVE_MODULE_NAME, 'isAirplaneModeEnabledAsync');
+  }
+  return expoNetwork.isAirplaneModeEnabledAsync();
+}
+
+/** Subscribe to network state changes (connection type, connected, internet reachable). */
+export function addNetworkStateListener(
+  listener: (event: NetworkStateEvent) => void,
+): EventSubscription {
+  return expoNetwork.addListener('onNetworkStateChanged', listener);
+}

package/src/core/types.ts

@@ -0,0 +1,60 @@
+// Hand-ported from .vendors/expo/packages/expo-network/src/Network.types.ts (sdk-57) — plain
+// data shapes, no `expo` meta-package import to swap out (unlike local-auth's types.ts).
+
+export enum NetworkStateType {
+  /** No active network connection detected. */
+  NONE = 'NONE',
+  /** The connection type could not be determined. */
+  UNKNOWN = 'UNKNOWN',
+  /** Active network connection over mobile data.
+   * @platform android
+   * @platform ios
+   */
+  CELLULAR = 'CELLULAR',
+  /** Active network connection over Wi-Fi.
+   * @platform android
+   * @platform ios
+   */
+  WIFI = 'WIFI',
+  /** Active network connection over Bluetooth.
+   * @platform android
+   */
+  BLUETOOTH = 'BLUETOOTH',
+  /** Active network connection over Ethernet.
+   * @platform android
+   * @platform ios
+   */
+  ETHERNET = 'ETHERNET',
+  /** Active network connection over WiMAX.
+   * @platform android
+   */
+  WIMAX = 'WIMAX',
+  /** Active network connection over VPN.
+   * @platform android
+   */
+  VPN = 'VPN',
+  /** Active network connection over other network connection types.
+   * @platform android
+   */
+  OTHER = 'OTHER',
+}
+
+export type NetworkState = {
+  /** The current network connection type. */
+  type?: NetworkStateType;
+  /**
+   * If there is an active network connection. Note that this does not mean internet is
+   * reachable. `false` when `type` is `NONE` or `UNKNOWN`, `true` otherwise.
+   */
+  isConnected?: boolean;
+  /**
+   * If the internet is reachable with the currently active network connection. On Android this
+   * requires internet capability, confirmed internet access, and a usable connection state; VPN
+   * connections also require non-zero downstream bandwidth. On iOS this always matches
+   * `isConnected`.
+   */
+  isInternetReachable?: boolean;
+};
+
+/** Passed as the argument to listeners registered with `addNetworkStateListener()`. */
+export type NetworkStateEvent = NetworkState;