@symbiote-native/network 0.0.1

package/src/react/hooks/use-network-state/index.ts

@@ -0,0 +1,17 @@
+// 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, type NetworkState } from '../../../core';
+
+export function useNetworkState(): NetworkState {
+  const [networkState, setNetworkState] = useState<NetworkState>({});
+
+  useEffect(() => {
+    getNetworkStateAsync().then(setNetworkState);
+    const subscription = addNetworkStateListener(event => setNetworkState(event));
+    return () => subscription.remove();
+  }, []);
+
+  return networkState;
+}

package/src/react/hooks/use-network-state/use-network-state.test.tsx

@@ -0,0 +1,91 @@
+// Co-located React-driven test (ADR 0025) for useNetworkState. See battery's
+// use-battery-state.test.tsx for the shared rationale (mocks `core`, not expo-modules-core
+// internals).
+
+import { createElement, type ReactElement } from 'react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mount, unmount, View } from '@symbiote-native/react';
+import { installFabric } from '@symbiote-native/test-utils';
+import { useNetworkState } from './index';
+
+type INetworkState = { type?: string; isConnected?: boolean; isInternetReachable?: boolean };
+
+const { addListener, getNetworkStateAsync, remove } = vi.hoisted(() => {
+  const remove = vi.fn();
+  return {
+    addListener: vi.fn((_listener: (event: INetworkState) => void) => ({ remove })),
+    getNetworkStateAsync: vi.fn(async () => ({
+      type: 'WIFI',
+      isConnected: true,
+      isInternetReachable: true,
+    })),
+    remove,
+  };
+});
+
+vi.mock('../../../core', () => ({
+  addNetworkStateListener: addListener,
+  getNetworkStateAsync,
+}));
+
+const ROOT_TAG = 953;
+
+const results: INetworkState[] = [];
+
+function Probe(): ReactElement {
+  results.push(useNetworkState());
+  return createElement(View);
+}
+
+const fabric = installFabric();
+
+beforeEach(() => {
+  fabric.reset();
+  results.length = 0;
+  vi.clearAllMocks();
+  getNetworkStateAsync.mockResolvedValue({
+    type: 'WIFI',
+    isConnected: true,
+    isInternetReachable: true,
+  });
+});
+
+afterEach(() => unmount(ROOT_TAG));
+
+describe('useNetworkState', () => {
+  it('reports an empty object before the initial fetch resolves', () => {
+    mount(ROOT_TAG, createElement(Probe));
+
+    expect(results[results.length - 1]).toEqual({});
+  });
+
+  it('reports the fetched state once the initial getNetworkStateAsync() resolves', async () => {
+    mount(ROOT_TAG, createElement(Probe));
+
+    await vi.waitFor(() =>
+      expect(results[results.length - 1]).toEqual({
+        type: 'WIFI',
+        isConnected: true,
+        isInternetReachable: true,
+      }),
+    );
+  });
+
+  it('updates when the native listener fires', async () => {
+    mount(ROOT_TAG, createElement(Probe));
+    await vi.waitFor(() => expect(results[results.length - 1].type).toBe('WIFI'));
+
+    const listener = addListener.mock.calls[0][0];
+    listener({ type: 'CELLULAR', isConnected: true, isInternetReachable: false });
+
+    await vi.waitFor(() => expect(results[results.length - 1].type).toBe('CELLULAR'));
+  });
+
+  it('unsubscribes from the native listener on unmount', () => {
+    mount(ROOT_TAG, createElement(Probe));
+
+    unmount(ROOT_TAG);
+
+    expect(remove).toHaveBeenCalledTimes(1);
+  });
+});

package/src/react/index.ts

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

package/src/vue/composables/use-network-state/index.ts

@@ -0,0 +1,31 @@
+// 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, type Ref } from '@vue/runtime-core';
+import {
+  addNetworkStateListener,
+  getNetworkStateAsync,
+  type EventSubscription,
+  type NetworkState,
+} from '../../../core';
+
+export function useNetworkState(): Ref<NetworkState> {
+  const networkState = ref<NetworkState>({});
+  let subscription: EventSubscription | undefined;
+
+  onMounted(() => {
+    getNetworkStateAsync().then(state => {
+      networkState.value = state;
+    });
+    subscription = addNetworkStateListener(event => {
+      networkState.value = event;
+    });
+  });
+
+  onUnmounted(() => {
+    subscription?.remove();
+  });
+
+  return networkState;
+}

package/src/vue/composables/use-network-state/use-network-state.test.ts

@@ -0,0 +1,100 @@
+// Co-located Vue-driven test (ADR 0025) for useNetworkState. See battery's
+// use-battery-state.test.ts for the shared rationale.
+
+import { defineComponent, h, type Ref } from '@vue/runtime-core';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mount, unmount } from '@symbiote-native/vue';
+import { installFabric } from '@symbiote-native/test-utils';
+import { useNetworkState } from './index';
+
+const ROOT_TAG = 9953;
+
+type INetworkState = { type?: string; isConnected?: boolean; isInternetReachable?: boolean };
+type IListener = (event: INetworkState) => void;
+
+let registeredListener: IListener | undefined;
+const removeMock = vi.fn();
+const addListenerMock = vi.fn((listener: IListener) => {
+  registeredListener = listener;
+  return { remove: removeMock };
+});
+const getNetworkStateAsyncMock = vi.fn(async () => ({
+  type: 'WIFI',
+  isConnected: true,
+  isInternetReachable: true,
+}));
+
+vi.mock('../../../core', () => ({
+  addNetworkStateListener: (listener: IListener) => addListenerMock(listener),
+  getNetworkStateAsync: () => getNetworkStateAsyncMock(),
+}));
+
+const fabric = installFabric();
+
+beforeEach(() => {
+  fabric.reset();
+  registeredListener = undefined;
+  addListenerMock.mockClear();
+  removeMock.mockClear();
+  getNetworkStateAsyncMock.mockClear();
+  getNetworkStateAsyncMock.mockResolvedValue({
+    type: 'WIFI',
+    isConnected: true,
+    isInternetReachable: true,
+  });
+});
+
+afterEach(() => unmount(ROOT_TAG));
+
+function mountNetworkState(): Ref<INetworkState> {
+  let networkState: Ref<INetworkState> | undefined;
+  mount(
+    ROOT_TAG,
+    defineComponent({
+      setup: () => {
+        networkState = useNetworkState();
+        return () => h('symbiote-text', {}, 'network');
+      },
+    }),
+  );
+  if (networkState === undefined) {
+    throw new Error('setup() did not run');
+  }
+  return networkState;
+}
+
+describe('useNetworkState (Vue)', () => {
+  it('starts at an empty object before the initial fetch resolves', () => {
+    const networkState = mountNetworkState();
+
+    expect(networkState.value).toEqual({});
+  });
+
+  it('updates to the fetched value once getNetworkStateAsync() resolves', async () => {
+    const networkState = mountNetworkState();
+
+    await vi.waitFor(() =>
+      expect(networkState.value).toEqual({
+        type: 'WIFI',
+        isConnected: true,
+        isInternetReachable: true,
+      }),
+    );
+  });
+
+  it('updates the ref when the native listener fires', async () => {
+    const networkState = mountNetworkState();
+    await vi.waitFor(() => expect(networkState.value.type).toBe('WIFI'));
+
+    registeredListener?.({ type: 'CELLULAR', isConnected: true, isInternetReachable: false });
+
+    expect(networkState.value.type).toBe('CELLULAR');
+  });
+
+  it('removes the subscription on unmount', () => {
+    mountNetworkState();
+    unmount(ROOT_TAG);
+
+    expect(removeMock).toHaveBeenCalledTimes(1);
+  });
+});

package/src/vue/index.ts

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