@symbiote-native/network 0.0.1 → 0.2.0

package/README.md

@@ -40,8 +40,8 @@ with zero further changes:
 
 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`.
+implementation: `examples/expo-react/ios/Podfile` and
+`examples/expo-react/android/app/src/main/java/com/canaryexpo/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

package/build/angular/index.d.ts

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

package/build/angular/index.js

@@ -1,4 +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';
+export * from '../core/index.js';

package/build/react/index.d.ts

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

package/build/react/index.js

@@ -1,3 +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';
+export * from '../core/index.js';

package/build/svelte/index.d.ts

@@ -0,0 +1,2 @@
+export { useNetworkState } from './runes/use-network-state.svelte';
+export * from '../core';

package/build/svelte/index.js

@@ -0,0 +1,5 @@
+// @symbiote-native/network/svelte: the Svelte entry over the framework-agnostic core — mirrors the
+// lifecycle-bucket naming convention of adapters/svelte/src/runes (never `hooks`/`composables`,
+// those are React's and Vue's terms).
+export { useNetworkState } from './runes/use-network-state.svelte';
+export * from '../core/index.js';

package/build/svelte/runes/use-network-state.svelte.d.ts

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

package/build/svelte/runes/use-network-state.svelte.js

@@ -0,0 +1,29 @@
+// Svelte 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 and the Vue composable's onMounted half.
+//
+// `.svelte.ts` extension: runes ($state/$effect) only work there outside a `.svelte` component;
+// `runes/` is Svelte's name for the lifecycle bucket (React's `hooks/`, Vue's `composables/`).
+// Returns a boxed getter, not a bare `$state`: Svelte 5 reactivity is lexically scoped to the
+// declaring module and doesn't survive being returned raw from a plain function, so the caller
+// reads `.current` like unwrapping Vue's `Ref` via `.value`.
+import { addNetworkStateListener, getNetworkStateAsync, } from '../../core/index.js';
+export function useNetworkState() {
+    let networkState = $state({});
+    $effect(() => {
+        // Write-only touches of `networkState`, so the effect has no dependency on it and runs once
+        // per mount - the twin of Vue's onMounted/onUnmounted pair.
+        getNetworkStateAsync().then(state => {
+            networkState = state;
+        });
+        const subscription = addNetworkStateListener(event => {
+            networkState = event;
+        });
+        return () => subscription.remove();
+    });
+    return {
+        get current() {
+            return networkState;
+        },
+    };
+}

package/build/vue/index.d.ts

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

package/build/vue/index.js

@@ -1,3 +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';
+export * from '../core/index.js';

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

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

package/build-ngc/angular/index.js

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

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

@@ -1 +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"}
+{"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,cAAc,SAAS,CAAC"}

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

@@ -17,10 +17,10 @@ export class NetworkStateService {
         }, { 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' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: NetworkStateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: NetworkStateService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: NetworkStateService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: NetworkStateService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbiote-native/network",
-  "version": "0.0.1",
+  "version": "0.2.0",
   "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": {
@@ -30,6 +30,10 @@
       "types": "./build/react/index.d.ts",
       "default": "./build/react/index.js"
     },
+    "./svelte": {
+      "types": "./build/svelte/index.d.ts",
+      "default": "./build/svelte/index.js"
+    },
     "./angular": {
       "types": "./build-ngc/angular/index.d.ts",
       "react-native": "./build-ngc/angular/index.js",
@@ -40,7 +44,10 @@
     "src",
     "build",
     "build-ngc",
-    "native-link.json"
+    "native-link.json",
+    "!src/**/*.test.*",
+    "!src/**/*.spec.*",
+    "!src/**/*.detox.*"
   ],
   "publishConfig": {
     "access": "public"
@@ -50,15 +57,17 @@
     "expo-modules-core": "57.0.5"
   },
   "peerDependencies": {
+    "@symbiote-native/angular": ">=0.6.2",
     "@symbiote-native/engine": ">=0.1.7",
+    "@symbiote-native/react": ">=0.2.8",
+    "@symbiote-native/svelte": ">=0.1.0",
+    "@symbiote-native/vue": ">=0.3.8",
     "@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"
+    "svelte": ">=5.56.0",
+    "vue": ">=3.5.0"
   },
   "peerDependenciesMeta": {
     "@symbiote-native/angular": {
@@ -67,6 +76,9 @@
     "@symbiote-native/react": {
       "optional": true
     },
+    "@symbiote-native/svelte": {
+      "optional": true
+    },
     "@symbiote-native/vue": {
       "optional": true
     },
@@ -79,24 +91,29 @@
     "react": {
       "optional": true
     },
+    "svelte": {
+      "optional": true
+    },
     "vue": {
       "optional": true
     }
   },
   "devDependencies": {
-    "@angular/compiler": "^22",
-    "@angular/compiler-cli": "^22",
-    "@angular/core": "^22",
+    "@angular/compiler": "~22.0.8",
+    "@angular/compiler-cli": "~22.0.8",
+    "@angular/core": "~22.0.8",
     "@types/node": "^26.0.0",
     "@types/react": "^19.2.0",
     "@vue/runtime-core": "^3.5.13",
     "react": "19.2.3",
+    "svelte": "^5.56.0",
     "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"
+    "@symbiote-native/angular": "0.7.0",
+    "@symbiote-native/engine": "0.2.0",
+    "@symbiote-native/react": "0.3.0",
+    "@symbiote-native/svelte": "0.2.0",
+    "@symbiote-native/test-utils": "0.1.6",
+    "@symbiote-native/vue": "0.4.0"
   },
   "scripts": {
     "typecheck": "tsc --build",

package/src/angular/index.ts

@@ -1,13 +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';
-export {
-  getNetworkStateAsync,
-  getIpAddressAsync,
-  isAirplaneModeEnabledAsync,
-  addNetworkStateListener,
-  NetworkStateType,
-  type NetworkState,
-  type NetworkStateEvent,
-  type EventSubscription,
-} from '../core';
+export * from '../core';

package/src/react/index.ts

@@ -1,13 +1,4 @@
 // @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';
+export * from '../core';

package/src/svelte/index.ts

@@ -0,0 +1,6 @@
+// @symbiote-native/network/svelte: the Svelte entry over the framework-agnostic core — mirrors the
+// lifecycle-bucket naming convention of adapters/svelte/src/runes (never `hooks`/`composables`,
+// those are React's and Vue's terms).
+
+export { useNetworkState } from './runes/use-network-state.svelte';
+export * from '../core';

package/src/svelte/runes/use-network-state.svelte.ts

@@ -0,0 +1,37 @@
+// Svelte 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 and the Vue composable's onMounted half.
+//
+// `.svelte.ts` extension: runes ($state/$effect) only work there outside a `.svelte` component;
+// `runes/` is Svelte's name for the lifecycle bucket (React's `hooks/`, Vue's `composables/`).
+// Returns a boxed getter, not a bare `$state`: Svelte 5 reactivity is lexically scoped to the
+// declaring module and doesn't survive being returned raw from a plain function, so the caller
+// reads `.current` like unwrapping Vue's `Ref` via `.value`.
+import {
+  addNetworkStateListener,
+  getNetworkStateAsync,
+  type EventSubscription,
+  type NetworkState,
+} from '../../core';
+
+export function useNetworkState(): { readonly current: NetworkState } {
+  let networkState = $state<NetworkState>({});
+
+  $effect(() => {
+    // Write-only touches of `networkState`, so the effect has no dependency on it and runs once
+    // per mount - the twin of Vue's onMounted/onUnmounted pair.
+    getNetworkStateAsync().then(state => {
+      networkState = state;
+    });
+    const subscription: EventSubscription = addNetworkStateListener(event => {
+      networkState = event;
+    });
+    return () => subscription.remove();
+  });
+
+  return {
+    get current(): NetworkState {
+      return networkState;
+    },
+  };
+}

package/src/svelte/svelte-ambient.d.ts

@@ -0,0 +1,6 @@
+// Pulls in svelte's ambient global declarations ($state/$effect/...) for this package's tsc
+// program. adapters/svelte gets these for free because render.ts does a real value import from
+// 'svelte' (any file in a program importing a module loads its ambient globals for the whole
+// program); this package has no such import, so a triple-slash reference does the same job
+// explicitly rather than relying on an incidental side-effect.
+/// <reference types="svelte" />

package/src/vue/index.ts

@@ -1,13 +1,4 @@
 // @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';
+export * from '../core';

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

@@ -1,103 +0,0 @@
-// 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/network.test.ts

@@ -1,103 +0,0 @@
-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/react/hooks/use-network-state/use-network-state.test.tsx

@@ -1,91 +0,0 @@
-// 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/vue/composables/use-network-state/use-network-state.test.ts

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