@symbiote-native/network 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 A. Prokopenko
+
+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,202 @@
+# @symbiote-native/network
+
+Port of [`expo-network`](https://docs.expo.dev/versions/latest/sdk/network/) for
+[SymbioteNative](../../README.md) — network connection state (type/connected/internet-reachable)
+with a change listener, device IP address, and airplane-mode detection, reachable from every
+adapter (React, Vue, Angular), not just React.
+
+Built the same way as [`@symbiote-native/battery`](../battery) and
+[`@symbiote-native/local-auth`](../local-auth), an `expo-modules-core`-based wrapper (see the
+`symbiote-expo-native-module` project skill for the full mechanism: why `expo-modules-core` is
+depended on directly and never the `expo` meta-package, why the upstream JS is hand-ported into
+`core/` rather than imported, and how autolinking picks up the native module).
+
+## Install
+
+```bash
+npm install @symbiote-native/network
+```
+
+Depends on `expo-network` and `expo-modules-core` directly (regular dependencies, pinned to exact
+versions — never a caret range, since this package's `core/` is hand-ported against one specific
+native API shape and a newer resolve could silently drift the two apart). Never install
+`expo-network` yourself, and never add the `expo` package to this project — it bundles its own
+Metro/Babel pipeline that conflicts with this project's own.
+
+### Required one-time step: native autolinking wiring
+
+Unlike a plain RN native module, `expo-network`'s native code is discovered by
+`expo-modules-autolinking`, not RN's own `react-native.config.cjs` mechanism — this needs wiring
+into the native host app **once**, covering this package and every other `expo-modules-core`
+package (`@symbiote-native/battery`, `@symbiote-native/sensors`, `@symbiote-native/local-auth`)
+with zero further changes:
+
+| Platform | Touches |
+|---|---|
+| iOS | `ios/Podfile` — add `use_expo_modules!` |
+| iOS | `AppDelegate.swift` — Expo's runtime-bootstrap hook |
+| Android | `settings.gradle` / `app/build.gradle` — resolve and include the Expo Gradle projects |
+| Android | `MainApplication.kt` — Expo's bootstrap hook, plus a hand-written native-module name map (there's no `expo` meta-package here to auto-generate one) |
+
+Full mechanics — the Podfile pieces that normally ship inside the `expo` package, the `expo`
+peer-dependency exclusion list — live in the `symbiote-expo-native-module` skill. Reference
+implementation: `.examples/expo-react/ios/Podfile` and
+`.examples/expo-react/android/app/src/main/java/com/canary/MainApplication.kt`.
+
+No platform permission string is needed for network's surface — connection state, IP address, and
+airplane-mode detection all read system state with no runtime permission prompt on either
+platform.
+
+## Shape
+
+```
+src/core/               network.ts — get*Async functions + addNetworkStateListener subscription.
+                        native-module.ts resolves the native module through expo-modules-core's
+                        requireNativeModule. types.ts — NetworkStateType enum, NetworkState,
+                        NetworkStateEvent, hand-ported from Network.types.ts.
+src/react/hooks/        @symbiote-native/network/react   — useNetworkState
+src/vue/composables/    @symbiote-native/network/vue     — useNetworkState (same name)
+src/angular/services/   @symbiote-native/network/angular — NetworkStateService (`.connect()`
+                        returns a Signal)
+```
+
+Each adapter's hook/composable/service is a thin lifecycle wrapper (seed from the one-shot
+`getNetworkStateAsync()` call, subscribe to `addNetworkStateListener`, unsubscribe on unmount) over
+the same `core` functions — the subscription logic is written once and shared by all three.
+
+## Use it
+
+```tsx
+// React — examples/expo-react/screens/NetworkScreen.tsx
+import { useEffect, useState } from 'react';
+import { getIpAddressAsync, isAirplaneModeEnabledAsync } from '@symbiote-native/network';
+import { useNetworkState } from '@symbiote-native/network/react';
+
+function NetworkScreen() {
+  const networkState = useNetworkState();          // { type, isConnected, isInternetReachable }
+  const [ipAddress, setIpAddress] = useState<string | null>(null);
+  const [isAirplaneMode, setIsAirplaneMode] = useState<boolean | null>(null);
+
+  useEffect(() => {
+    Promise.all([getIpAddressAsync(), isAirplaneModeEnabledAsync()]).then(([ip, airplaneMode]) => {
+      setIpAddress(ip);
+      setIsAirplaneMode(airplaneMode);
+    });
+  }, [networkState]);
+
+  return (
+    <>
+      <Text>{networkState.isConnected ? `Connected via ${networkState.type}` : 'Offline'}</Text>
+      <Text>{ipAddress ?? 'checking…'}</Text>
+      <Text>{isAirplaneMode ? 'Airplane mode: On' : 'Airplane mode: Off'}</Text>
+    </>
+  );
+}
+```
+
+```vue
+<!-- Vue — examples/expo-vue-sfc/screens/NetworkScreen.vue -->
+<script setup lang="ts">
+import { ref, watch } from 'vue';
+import { Text } from '@symbiote-native/vue';
+import { getIpAddressAsync, isAirplaneModeEnabledAsync } from '@symbiote-native/network';
+import { useNetworkState } from '@symbiote-native/network/vue';
+
+const networkState = useNetworkState();           // Ref<NetworkState>
+const ipAddress = ref<string | null>(null);
+const isAirplaneMode = ref<boolean | null>(null);
+
+watch(
+  networkState,
+  () => {
+    void Promise.all([getIpAddressAsync(), isAirplaneModeEnabledAsync()]).then(([ip, airplaneMode]) => {
+      ipAddress.value = ip;
+      isAirplaneMode.value = airplaneMode;
+    });
+  },
+  { immediate: true },
+);
+</script>
+<template>
+  <Text>{{ networkState.isConnected ? `Connected via ${networkState.type}` : 'Offline' }}</Text>
+  <Text>{{ ipAddress ?? 'checking…' }}</Text>
+</template>
+```
+
+```ts
+// Angular — examples/expo-angular/src/screens/NetworkScreen.ts
+import { Component, effect, inject, signal } from '@angular/core';
+import { Text } from '@symbiote-native/angular';
+import {
+  NetworkStateService,
+  getIpAddressAsync,
+  isAirplaneModeEnabledAsync,
+} from '@symbiote-native/network/angular';
+
+@Component({
+  standalone: true,
+  imports: [Text],
+  template: `<Text>{{ ipAddress() }}</Text>`,
+})
+export class NetworkScreen {
+  readonly networkState = inject(NetworkStateService).connect(); // Signal<NetworkState>
+  readonly ipAddress = signal<string | null>(null);
+
+  constructor() {
+    effect(() => {
+      this.networkState();
+      Promise.all([getIpAddressAsync(), isAirplaneModeEnabledAsync()]).then(([ip]) => {
+        this.ipAddress.set(ip);
+      });
+    });
+  }
+}
+```
+
+Each of the three demo screens above also re-fetches the IP address and airplane-mode card
+whenever the live network state changes (toggling Wi-Fi/airplane mode on the device updates both
+cards together) — see the linked files for the full version, including the connection-type label
+switch and the layout around it.
+
+## API
+
+A mix of stateless async functions and one listener-based subscription
+(`addNetworkStateListener`), with its own adapter-level lifecycle hook.
+
+```ts
+getNetworkStateAsync(): Promise<NetworkState>          // { type, isConnected, isInternetReachable }
+getIpAddressAsync(): Promise<string>                    // device's IPv4 address, "0.0.0.0" if unavailable
+isAirplaneModeEnabledAsync(): Promise<boolean>          // Android only
+addNetworkStateListener(listener): EventSubscription     // fires whenever the network state changes
+```
+
+Plus `NetworkStateType` (enum: `NONE`/`UNKNOWN`/`CELLULAR`/`WIFI`/`BLUETOOTH`/`ETHERNET`/`WIMAX`/
+`VPN`/`OTHER`), `NetworkState`, `NetworkStateEvent` — ported from upstream's `Network.types.ts`.
+
+```ts
+import { getNetworkStateAsync, addNetworkStateListener } from '@symbiote-native/network';
+
+// framework-scoped entry points re-export the same free functions, plus a lifecycle
+// hook/composable/service:
+import { useNetworkState } from '@symbiote-native/network/react';
+import { useNetworkState } from '@symbiote-native/network/vue';
+import { NetworkStateService } from '@symbiote-native/network/angular';
+```
+
+`useNetworkState` seeds its initial value from a one-shot `getNetworkStateAsync()` call, then
+subscribes to `addNetworkStateListener` for updates, and unsubscribes on unmount — mirroring
+upstream's own `useNetworkState`.
+
+## Test it
+
+No Fabric/Descriptor angle at all — network is a pure async-function + `EventEmitter` listener
+surface, never a view. Tests inject a fake native-module object in place of the real
+`requireNativeModule` resolution (`src/core/network.test.ts`,
+`src/{react,vue,angular}/**/*.test.{ts,tsx}`, `vitest`), the same pattern
+`@symbiote-native/battery`/`@symbiote-native/sensors`/`@symbiote-native/local-auth` use — no
+`installFabric()`, no ViewConfig. Native rendering itself is verified on-device — see the parent
+[README](../../README.md).
+
+The Android/iOS native wiring is done across all four `examples/expo-*` canary apps
+(`examples/expo-react`, `examples/expo-vue-sfc`, `examples/expo-vue-tsx`, `examples/expo-angular`);
+this package isn't yet in the public, non-Expo `examples/react` canary.

package/build/angular/index.d.ts

@@ -0,0 +1,2 @@
+export { NetworkStateService } from './services/network-state.service';
+export { getNetworkStateAsync, getIpAddressAsync, isAirplaneModeEnabledAsync, addNetworkStateListener, NetworkStateType, type NetworkState, type NetworkStateEvent, type EventSubscription, } from '../core';

package/build/angular/index.js

@@ -0,0 +1,4 @@
+// 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/index.js';
+export { getNetworkStateAsync, getIpAddressAsync, isAirplaneModeEnabledAsync, addNetworkStateListener, NetworkStateType, } from '../core/index.js';

package/build/angular/services/network-state.service/index.d.ts

@@ -0,0 +1,6 @@
+import { type Signal } from '@angular/core';
+import { type NetworkState } from '../../../core';
+export declare class NetworkStateService {
+    private readonly injector;
+    connect(): Signal<NetworkState>;
+}

package/build/angular/services/network-state.service/index.js

@@ -0,0 +1,68 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { effect, inject, Injectable, Injector, signal } from '@angular/core';
+import { addNetworkStateListener, getNetworkStateAsync } from '../../../core/index.js';
+// Angular twin of React's `useNetworkState` hook and Vue's `useNetworkState` composable.
+//
+//   readonly networkState = inject(NetworkStateService).connect();
+//   // template: {{ networkState().type }}
+let NetworkStateService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var NetworkStateService = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            NetworkStateService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        injector = inject(Injector);
+        connect() {
+            const networkState = signal({});
+            effect(onCleanup => {
+                getNetworkStateAsync().then(state => networkState.set(state));
+                const subscription = addNetworkStateListener(event => networkState.set(event));
+                onCleanup(() => subscription.remove());
+            }, { injector: this.injector });
+            return networkState.asReadonly();
+        }
+    };
+    return NetworkStateService = _classThis;
+})();
+export { NetworkStateService };

package/build/core/index.d.ts

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

package/build/core/index.js

@@ -0,0 +1,2 @@
+export { getNetworkStateAsync, getIpAddressAsync, isAirplaneModeEnabledAsync, addNetworkStateListener, } from './network.js';
+export { NetworkStateType } from './types.js';

package/build/core/native-module.d.ts

@@ -0,0 +1,9 @@
+import type { EventSubscription } from 'expo-modules-core';
+import type { NetworkStateEvent } from './types';
+export type INativeNetworkModule = {
+    getNetworkStateAsync?(): Promise<NetworkStateEvent>;
+    getIpAddressAsync?(): Promise<string>;
+    isAirplaneModeEnabledAsync?(): Promise<boolean>;
+    addListener(eventName: 'onNetworkStateChanged', listener: (event: NetworkStateEvent) => void): EventSubscription;
+};
+export declare const expoNetwork: INativeNetworkModule;

package/build/core/native-module.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_NETWORK_MODULE_NAME = 'ExpoNetwork';
+export const expoNetwork = requireNativeModule(EXPO_NETWORK_MODULE_NAME);

package/build/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/core/network.js

@@ -0,0 +1,34 @@
+// 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.js';
+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);
+}

package/build/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/core/types.js

@@ -0,0 +1,40 @@
+// 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 = {}));

package/build/react/hooks/use-network-state/index.d.ts

@@ -0,0 +1,2 @@
+import { type NetworkState } from '../../../core';
+export declare function useNetworkState(): NetworkState;

package/build/react/hooks/use-network-state/index.js

@@ -0,0 +1,14 @@
+// React lifecycle wiring over the framework-agnostic core (core/network.ts). Seeds the initial
+// value with a one-shot getNetworkStateAsync() call before the first native event fires, matching
+// upstream's own useNetworkState.
+import { useEffect, useState } from 'react';
+import { addNetworkStateListener, getNetworkStateAsync } from '../../../core/index.js';
+export function useNetworkState() {
+    const [networkState, setNetworkState] = useState({});
+    useEffect(() => {
+        getNetworkStateAsync().then(setNetworkState);
+        const subscription = addNetworkStateListener(event => setNetworkState(event));
+        return () => subscription.remove();
+    }, []);
+    return networkState;
+}

package/build/react/index.d.ts

@@ -0,0 +1,2 @@
+export { useNetworkState } from './hooks/use-network-state';
+export { getNetworkStateAsync, getIpAddressAsync, isAirplaneModeEnabledAsync, addNetworkStateListener, NetworkStateType, type NetworkState, type NetworkStateEvent, type EventSubscription, } from '../core';

package/build/react/index.js

@@ -0,0 +1,3 @@
+// @symbiote-native/network/react: the React entry over the framework-agnostic core.
+export { useNetworkState } from './hooks/use-network-state/index.js';
+export { getNetworkStateAsync, getIpAddressAsync, isAirplaneModeEnabledAsync, addNetworkStateListener, NetworkStateType, } from '../core/index.js';

package/build/vue/composables/use-network-state/index.d.ts

@@ -0,0 +1,3 @@
+import { type Ref } from '@vue/runtime-core';
+import { type NetworkState } from '../../../core';
+export declare function useNetworkState(): Ref<NetworkState>;

package/build/vue/composables/use-network-state/index.js

@@ -0,0 +1,21 @@
+// Vue lifecycle wiring over the framework-agnostic core (core/network.ts). Seeds the initial
+// value with a one-shot getNetworkStateAsync() call before the first native event fires, matching
+// upstream's own useNetworkState.
+import { onMounted, onUnmounted, ref } from '@vue/runtime-core';
+import { addNetworkStateListener, getNetworkStateAsync, } from '../../../core/index.js';
+export function useNetworkState() {
+    const networkState = ref({});
+    let subscription;
+    onMounted(() => {
+        getNetworkStateAsync().then(state => {
+            networkState.value = state;
+        });
+        subscription = addNetworkStateListener(event => {
+            networkState.value = event;
+        });
+    });
+    onUnmounted(() => {
+        subscription?.remove();
+    });
+    return networkState;
+}

package/build/vue/index.d.ts

@@ -0,0 +1,2 @@
+export { useNetworkState } from './composables/use-network-state';
+export { getNetworkStateAsync, getIpAddressAsync, isAirplaneModeEnabledAsync, addNetworkStateListener, NetworkStateType, type NetworkState, type NetworkStateEvent, type EventSubscription, } from '../core';

package/build/vue/index.js

@@ -0,0 +1,3 @@
+// @symbiote-native/network/vue: the Vue entry over the framework-agnostic core.
+export { useNetworkState } from './composables/use-network-state/index.js';
+export { getNetworkStateAsync, getIpAddressAsync, isAirplaneModeEnabledAsync, addNetworkStateListener, NetworkStateType, } from '../core/index.js';

package/build-ngc/angular/index.d.ts

@@ -0,0 +1,2 @@
+export { NetworkStateService } from './services/network-state.service';
+export { getNetworkStateAsync, getIpAddressAsync, isAirplaneModeEnabledAsync, addNetworkStateListener, NetworkStateType, type NetworkState, type NetworkStateEvent, type EventSubscription, } from '../core';

package/build-ngc/angular/index.js

@@ -0,0 +1,5 @@
+// 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, } from '../core';
+//# sourceMappingURL=index.js.map

package/build-ngc/angular/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,iEAAiE;AACjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EACL,oBAAoB,EACpB,iBAAiB,EACjB,0BAA0B,EAC1B,uBAAuB,EACvB,gBAAgB,GAIjB,MAAM,SAAS,CAAC"}

package/build-ngc/angular/services/network-state.service/index.d.ts

@@ -0,0 +1,9 @@
+import { type Signal } from '@angular/core';
+import { type NetworkState } from '../../../core';
+import * as i0 from "@angular/core";
+export declare class NetworkStateService {
+    private readonly injector;
+    connect(): Signal<NetworkState>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NetworkStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NetworkStateService>;
+}

package/build-ngc/angular/services/network-state.service/index.js

@@ -0,0 +1,27 @@
+import { effect, inject, Injectable, Injector, signal } from '@angular/core';
+import { addNetworkStateListener, getNetworkStateAsync } from '../../../core';
+import * as i0 from "@angular/core";
+// Angular twin of React's `useNetworkState` hook and Vue's `useNetworkState` composable.
+//
+//   readonly networkState = inject(NetworkStateService).connect();
+//   // template: {{ networkState().type }}
+export class NetworkStateService {
+    injector = inject(Injector);
+    connect() {
+        const networkState = signal({}, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "networkState" }] : /* istanbul ignore next */ []));
+        effect(onCleanup => {
+            getNetworkStateAsync().then(state => networkState.set(state));
+            const subscription = addNetworkStateListener(event => networkState.set(event));
+            onCleanup(() => subscription.remove());
+        }, { injector: this.injector });
+        return networkState.asReadonly();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: NetworkStateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: NetworkStateService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: NetworkStateService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=index.js.map

package/build-ngc/angular/services/network-state.service/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/angular/services/network-state.service/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAe,MAAM,eAAe,CAAC;AAC1F,OAAO,EAAE,uBAAuB,EAAE,oBAAoB,EAAqB,MAAM,eAAe,CAAC;;AAEjG,yFAAyF;AACzF,EAAE;AACF,mEAAmE;AACnE,2CAA2C;AAE3C,MAAM,OAAO,mBAAmB;IACb,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;IAE7C,OAAO;QACL,MAAM,YAAY,GAAG,MAAM,CAAe,EAAE;yFAAC,CAAC;QAE9C,MAAM,CACJ,SAAS,CAAC,EAAE;YACV,oBAAoB,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;YAC9D,MAAM,YAAY,GAAG,uBAAuB,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;YAC/E,SAAS,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC;QACzC,CAAC,EACD,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAC5B,CAAC;QAEF,OAAO,YAAY,CAAC,UAAU,EAAE,CAAC;IACnC,CAAC;uGAhBU,mBAAmB;2GAAnB,mBAAmB,cADN,MAAM;;2FACnB,mBAAmB;kBAD/B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE"}

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

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

package/build-ngc/core/index.js

@@ -0,0 +1,3 @@
+export { getNetworkStateAsync, getIpAddressAsync, isAirplaneModeEnabledAsync, addNetworkStateListener, } from './network';
+export { NetworkStateType } from './types';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,iBAAiB,EACjB,0BAA0B,EAC1B,uBAAuB,GACxB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,gBAAgB,EAA6C,MAAM,SAAS,CAAC"}

package/build-ngc/core/native-module.d.ts

@@ -0,0 +1,9 @@
+import type { EventSubscription } from 'expo-modules-core';
+import type { NetworkStateEvent } from './types';
+export type INativeNetworkModule = {
+    getNetworkStateAsync?(): Promise<NetworkStateEvent>;
+    getIpAddressAsync?(): Promise<string>;
+    isAirplaneModeEnabledAsync?(): Promise<boolean>;
+    addListener(eventName: 'onNetworkStateChanged', listener: (event: NetworkStateEvent) => void): EventSubscription;
+};
+export declare const expoNetwork: INativeNetworkModule;

package/build-ngc/core/native-module.js

@@ -0,0 +1,4 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_NETWORK_MODULE_NAME = 'ExpoNetwork';
+export const expoNetwork = requireNativeModule(EXPO_NETWORK_MODULE_NAME);
+//# sourceMappingURL=native-module.js.map

package/build-ngc/core/native-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-module.js","sourceRoot":"","sources":["../../src/core/native-module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAIxD,MAAM,wBAAwB,GAAG,aAAa,CAAC;AAc/C,MAAM,CAAC,MAAM,WAAW,GAAG,mBAAmB,CAAuB,wBAAwB,CAAC,CAAC"}