@symbiote-native/battery 3.0.1 → 3.0.3

package/README.md

@@ -1,7 +1,7 @@
 # @symbiote-native/battery
 
 Port of [`expo-battery`](https://docs.expo.dev/versions/latest/sdk/battery/) for
-[SymbioteNative](../../README.md) — battery level and state, low-power-mode detection, reachable
+[SymbioteNative](../../README.md) - battery level and state, low-power-mode detection, reachable
 from every adapter (React, Vue, Svelte, Solid, Angular), not just React.
 
 Built the same way as [`@symbiote-native/local-auth`](../local-auth) and
@@ -24,74 +24,74 @@ npx @symbiote-native/cli new my-app --battery
 npx @symbiote-native/cli add --battery
 ```
 
-Either way: installs `@symbiote-native/battery` and wires the native autolinking automatically — see
+Either way: installs `@symbiote-native/battery` and wires the native autolinking automatically - see
 [`@symbiote-native/cli`](../cli).
 
 <details>
-<summary>Manual install (no CLI — installing and wiring native autolinking by hand)</summary>
+<summary>Manual install (no CLI - installing and wiring native autolinking by hand)</summary>
 
 ```bash
 npm install @symbiote-native/battery
 ```
 
 Depends on `expo-battery` 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
+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-battery` yourself, and never add the `expo` package to this project — it bundles its own
+`expo-battery` 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-battery`'s native code is discovered by
-`expo-modules-autolinking`, not RN's own `react-native.config.cjs` mechanism — this needs wiring
+`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/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) |
+| 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
+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/canaryexpo/MainApplication.kt`.
 
 </details>
 
-No platform permission string is needed for battery's basic surface —
+No platform permission string is needed for battery's basic surface:
 `isBatteryOptimizationEnabledAsync` reads an Android-only system state with no runtime permission
 prompt either.
 
 ## Shape
 
 ```
-src/core/               Battery.ts — one-shot get*Async functions + addListener subscriptions.
+src/core/               Battery.ts - one-shot get*Async functions + addListener subscriptions.
                         native-module.ts resolves the native module through expo-modules-core's
-                        requireNativeModule. types.ts — BatteryState enum, PowerState,
+                        requireNativeModule. types.ts - BatteryState enum, PowerState,
                         *Event shapes, hand-ported from Battery.types.ts.
-src/react/hooks/        @symbiote-native/battery/react   — useBatteryLevel, useBatteryState,
-                        useLowPowerMode
-src/vue/composables/    @symbiote-native/battery/vue     — same three names, Vue lifecycle
-src/svelte/runes/       @symbiote-native/battery/svelte  — same three names, read as `.current`
-src/solid/primitives/   @symbiote-native/battery/solid   — createBatteryLevel, createBatteryState,
-                        createLowPowerMode (each returns an Accessor)
-src/angular/services/   @symbiote-native/battery/angular — BatteryLevelService, BatteryStateService,
-                        LowPowerModeService (`.connect()` returns a Signal)
+src/react/hooks/        @symbiote-native/battery/react   - useBatteryLevel, useBatteryState,
+                        useLowPowerMode, usePowerState
+src/vue/composables/    @symbiote-native/battery/vue     - same four names, Vue lifecycle
+src/svelte/runes/       @symbiote-native/battery/svelte  - same four names, read as `.current`
+src/solid/primitives/   @symbiote-native/battery/solid   - createBatteryLevel, createBatteryState,
+                        createLowPowerMode, createPowerState (each returns an Accessor)
+src/angular/services/   @symbiote-native/battery/angular - BatteryLevelService, BatteryStateService,
+                        LowPowerModeService, PowerStateService (`.connect()` returns a Signal)
 ```
 
 Each adapter's hook/composable/rune/primitive/service is a thin lifecycle wrapper (seed from the
 one-shot `get*Async` call, subscribe to the matching listener, unsubscribe on unmount/cleanup)
-over the same `core` functions — the subscription and fallback logic is written once and shared
+over the same `core` functions - the subscription and fallback logic is written once and shared
 by every adapter. Solid's naming differs on purpose: `create*`, not `use*`, which Solid reserves
 for consuming something that already exists.
 
 ## Use it
 
 ```tsx
-// React — examples/expo-react/screens/BatteryScreen.tsx
+// React - examples/expo-react/screens/BatteryScreen.tsx
 import {
   useBatteryLevel,
   useBatteryState,
@@ -120,7 +120,7 @@ function BatteryScreen() {
 ```
 
 ```vue
-<!-- Vue — examples/expo-vue-sfc/screens/BatteryScreen.vue -->
+<!-- Vue - examples/expo-vue-sfc/screens/BatteryScreen.vue -->
 <script setup lang="ts">
 import { computed } from 'vue';
 import {
@@ -146,7 +146,7 @@ const batteryLevelText = computed(() =>
 ```
 
 ```svelte
-<!-- Svelte — examples/expo-svelte/screens/BatteryScreen.svelte. Each rune returns a boxed
+<!-- Svelte - examples/expo-svelte/screens/BatteryScreen.svelte. Each rune returns a boxed
      getter object, read as `.current`, since a bare `$state` doesn't survive being handed out
      of a plain function. -->
 <script lang="ts">
@@ -176,7 +176,7 @@ const batteryLevelText = computed(() =>
 ```
 
 ```tsx
-// Solid — an accessor per value; call it to read, so a component body that runs once still
+// Solid - an accessor per value; call it to read, so a component body that runs once still
 // re-renders the leaf that reads it.
 import {
   createBatteryLevel,
@@ -207,7 +207,7 @@ function BatteryScreen() {
 ```
 
 ```ts
-// Angular — examples/expo-angular/src/screens/BatteryScreen.ts
+// Angular - examples/expo-angular/src/screens/BatteryScreen.ts
 import { Component, inject } from '@angular/core';
 import {
   BatteryLevelService,
@@ -230,7 +230,7 @@ export class BatteryScreen {
 
 Each of the demo screens above also renders a one-shot capabilities card
 (`isAvailableAsync()`, and Android-only `isBatteryOptimizationEnabledAsync()`) resolved directly
-from `@symbiote-native/battery`'s core entry point — see the linked files for the full version.
+from `@symbiote-native/battery`'s core entry point - see the linked files for the full version.
 The iOS Simulator reports the battery API as unavailable (`isAvailableAsync()` resolves `false`)
 since simulators have no real battery hardware; a physical device is needed to see live readings.
 
@@ -238,9 +238,9 @@ since simulators have no real battery hardware; a physical device is needed to s
 
 A mix of stateless async functions and three listener-based subscriptions
 (`addBatteryLevelListener`/`addBatteryStateListener`/`addLowPowerModeListener`), each with its
-own adapter-level lifecycle hook — one hook/composable/service per listener, matching upstream's
-own `useBatteryLevel`/`useBatteryState`/`useLowPowerMode` being three separate hooks, not one
-combined hook.
+own adapter-level lifecycle hook, matching upstream's `useBatteryLevel`/`useBatteryState`/
+`useLowPowerMode`. `usePowerState` merges all three into one `PowerState` value; the seed and
+merge logic is `watchPowerState` in core, so every adapter only holds the state.
 
 ```ts
 isAvailableAsync(): Promise<boolean>                          // battery API availability on this device
@@ -255,7 +255,7 @@ addLowPowerModeListener(listener): EventSubscription           // fires when low
 ```
 
 Plus `BatteryState` (enum), `PowerState`, `BatteryLevelEvent`, `BatteryStateEvent`,
-`PowerModeEvent` — ported from upstream's `Battery.types.ts`.
+`PowerModeEvent` - ported from upstream's `Battery.types.ts`.
 
 ```ts
 import {
@@ -269,42 +269,57 @@ import {
   useBatteryLevel,
   useBatteryState,
   useLowPowerMode,
+  usePowerState,
 } from '@symbiote-native/battery/react';
 import {
   useBatteryLevel,
   useBatteryState,
   useLowPowerMode,
+  usePowerState,
 } from '@symbiote-native/battery/vue';
 import {
   useBatteryLevel,
   useBatteryState,
   useLowPowerMode,
+  usePowerState,
 } from '@symbiote-native/battery/svelte';
 import {
   createBatteryLevel,
   createBatteryState,
   createLowPowerMode,
+  createPowerState,
 } from '@symbiote-native/battery/solid';
 import {
   BatteryLevelService,
   BatteryStateService,
   LowPowerModeService,
+  PowerStateService,
 } from '@symbiote-native/battery/angular';
 ```
 
 Each hook/composable/service seeds its initial value from the matching one-shot
 `get*Async`/`is*Async` call, then subscribes to the matching listener for updates, and
-unsubscribes on unmount — mirroring upstream's own `useBatteryLevel`/`useBatteryState`/
+unsubscribes on unmount - mirroring upstream's own `useBatteryLevel`/`useBatteryState`/
 `useLowPowerMode`.
 
+## Common questions
+
+- **Level reads `-1`.** Unknown level (simulator, unsupported device): check for `-1` before
+  formatting and do not treat it as low battery.
+- **Live updates?** Read the initial level, then subscribe to the listener and clean up on unmount.
+- **Low Power Mode?** Use the low power mode query and listener to reduce background work.
+
+Sources: [Expo docs: Battery](https://docs.expo.dev/versions/latest/sdk/battery/),
+[Battery -100% bug report](https://github.com/karlgroves/bugrout/issues/202).
+
 ## Test it
 
-No Fabric/Descriptor angle at all — battery is a pure async-function + `EventEmitter` listener
+No Fabric/Descriptor angle at all - battery 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/battery.test.ts`,
 `src/{react,vue,svelte,solid,angular}/**/*.test.{ts,tsx}`, `vitest`), the same pattern
-`@symbiote-native/sensors` and `@symbiote-native/local-auth` use — no `installFabric()`, no
-ViewConfig. Native rendering itself is verified on-device — see the parent
+`@symbiote-native/sensors` and `@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 six `examples/expo-*` canary apps

package/build/angular/index.d.ts

@@ -1,4 +1,5 @@
 export { BatteryLevelService } from './services/battery-level.service';
 export { BatteryStateService } from './services/battery-state.service';
 export { LowPowerModeService } from './services/low-power-mode.service';
+export { PowerStateService } from './services/power-state.service';
 export * from '../core';

package/build/angular/index.js

@@ -5,4 +5,5 @@
 export { BatteryLevelService } from './services/battery-level.service/index.js';
 export { BatteryStateService } from './services/battery-state.service/index.js';
 export { LowPowerModeService } from './services/low-power-mode.service/index.js';
+export { PowerStateService } from './services/power-state.service/index.js';
 export * from '../core/index.js';

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

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

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

@@ -0,0 +1,60 @@
+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 { inject, Injectable, Injector } from '@angular/core';
+import { connectWatchedSignal } from '@symbiote-native/angular';
+import { initialPowerState, watchPowerState, } from '../../../core/index.js';
+// Angular twin of `usePowerState`, same `connect()` pattern as `BatteryLevelService`
+let PowerStateService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var PowerStateService = 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);
+            PowerStateService = _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() {
+            return connectWatchedSignal(this.injector, initialPowerState, watchPowerState);
+        }
+    };
+    return PowerStateService = _classThis;
+})();
+export { PowerStateService };

package/build/core/index.d.ts

@@ -1,3 +1,4 @@
 export { isAvailableAsync, getBatteryLevelAsync, getBatteryStateAsync, isLowPowerModeEnabledAsync, isBatteryOptimizationEnabledAsync, getPowerStateAsync, addBatteryLevelListener, addBatteryStateListener, addLowPowerModeListener, } from './battery';
 export { BatteryState, type PowerState, type BatteryLevelEvent, type BatteryStateEvent, type PowerModeEvent, } from './types';
+export { initialPowerState, watchPowerState } from './power-state';
 export type { EventSubscription } from 'expo-modules-core';

package/build/core/index.js

@@ -1,2 +1,3 @@
 export { isAvailableAsync, getBatteryLevelAsync, getBatteryStateAsync, isLowPowerModeEnabledAsync, isBatteryOptimizationEnabledAsync, getPowerStateAsync, addBatteryLevelListener, addBatteryStateListener, addLowPowerModeListener, } from './battery.js';
 export { BatteryState, } from './types.js';
+export { initialPowerState, watchPowerState } from './power-state.js';

package/build/core/power-state.d.ts

@@ -0,0 +1,3 @@
+import { type PowerState } from './types';
+export declare const initialPowerState: PowerState;
+export declare function watchPowerState(onChange: (state: PowerState) => void): () => void;

package/build/core/power-state.js

@@ -0,0 +1,37 @@
+// Shared half of upstream's `usePowerState`: level, state and low-power mode as one merged value
+import { addBatteryLevelListener, addBatteryStateListener, addLowPowerModeListener, getBatteryLevelAsync, getBatteryStateAsync, isLowPowerModeEnabledAsync, } from './battery.js';
+import { BatteryState } from './types.js';
+export const initialPowerState = {
+    lowPowerMode: false,
+    batteryLevel: -1,
+    batteryState: BatteryState.UNKNOWN,
+};
+// Seeds each field with a one-shot fetch, then follows native events; returns the teardown
+export function watchPowerState(onChange) {
+    let state = initialPowerState;
+    let isStopped = false;
+    const heardFields = new Set();
+    // A native event that lands before its seed resolves wins because the seed is the older value
+    function write(key, value, isSeed) {
+        if (isStopped || (isSeed && heardFields.has(key))) {
+            return;
+        }
+        if (!isSeed) {
+            heardFields.add(key);
+        }
+        state = { ...state, [key]: value };
+        onChange(state);
+    }
+    const subscriptions = [
+        addLowPowerModeListener(event => write('lowPowerMode', event.lowPowerMode, false)),
+        addBatteryLevelListener(event => write('batteryLevel', event.batteryLevel, false)),
+        addBatteryStateListener(event => write('batteryState', event.batteryState, false)),
+    ];
+    isLowPowerModeEnabledAsync().then(value => write('lowPowerMode', value, true));
+    getBatteryLevelAsync().then(value => write('batteryLevel', value, true));
+    getBatteryStateAsync().then(value => write('batteryState', value, true));
+    return () => {
+        isStopped = true;
+        subscriptions.forEach(subscription => subscription.remove());
+    };
+}

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

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

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

@@ -0,0 +1,8 @@
+// React lifecycle wiring over `watchPowerState` from core, twin of upstream's `usePowerState`
+import { useEffect, useState } from 'react';
+import { initialPowerState, watchPowerState, } from '../../../core/index.js';
+export function usePowerState() {
+    const [powerState, setPowerState] = useState(initialPowerState);
+    useEffect(() => watchPowerState(setPowerState), []);
+    return powerState;
+}

package/build/react/index.d.ts

@@ -1,4 +1,5 @@
 export { useBatteryLevel } from './hooks/use-battery-level';
 export { useBatteryState } from './hooks/use-battery-state';
 export { useLowPowerMode } from './hooks/use-low-power-mode';
+export { usePowerState } from './hooks/use-power-state';
 export * from '../core';

package/build/react/index.js

@@ -6,4 +6,5 @@
 export { useBatteryLevel } from './hooks/use-battery-level/index.js';
 export { useBatteryState } from './hooks/use-battery-state/index.js';
 export { useLowPowerMode } from './hooks/use-low-power-mode/index.js';
+export { usePowerState } from './hooks/use-power-state/index.js';
 export * from '../core/index.js';

package/build/solid/index.d.ts

@@ -1,4 +1,5 @@
 export { createBatteryLevel } from './primitives/create-battery-level';
 export { createBatteryState } from './primitives/create-battery-state';
 export { createLowPowerMode } from './primitives/create-low-power-mode';
+export { createPowerState } from './primitives/create-power-state';
 export * from '../core';

package/build/solid/index.js

@@ -7,4 +7,5 @@
 export { createBatteryLevel } from './primitives/create-battery-level.js';
 export { createBatteryState } from './primitives/create-battery-state.js';
 export { createLowPowerMode } from './primitives/create-low-power-mode.js';
+export { createPowerState } from './primitives/create-power-state.js';
 export * from '../core/index.js';

package/build/solid/primitives/create-power-state.d.ts

@@ -0,0 +1,3 @@
+import { type Accessor } from 'solid-js';
+import { type PowerState } from '../../core';
+export declare function createPowerState(): Accessor<PowerState>;

package/build/solid/primitives/create-power-state.js

@@ -0,0 +1,8 @@
+// Solid lifecycle wiring over `watchPowerState` from core, twin of upstream's `usePowerState`
+import { createSignal, onCleanup } from 'solid-js';
+import { initialPowerState, watchPowerState, } from '../../core/index.js';
+export function createPowerState() {
+    const [powerState, setPowerState] = createSignal(initialPowerState);
+    onCleanup(watchPowerState(setPowerState));
+    return powerState;
+}

package/build/svelte/index.d.ts

@@ -1,4 +1,5 @@
 export { useBatteryLevel } from './runes/use-battery-level.svelte';
 export { useBatteryState } from './runes/use-battery-state.svelte';
 export { useLowPowerMode } from './runes/use-low-power-mode.svelte';
+export { usePowerState } from './runes/use-power-state.svelte';
 export * from '../core';

package/build/svelte/index.js

@@ -6,4 +6,5 @@
 export { useBatteryLevel } from './runes/use-battery-level.svelte';
 export { useBatteryState } from './runes/use-battery-state.svelte';
 export { useLowPowerMode } from './runes/use-low-power-mode.svelte';
+export { usePowerState } from './runes/use-power-state.svelte';
 export * from '../core/index.js';

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

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

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

@@ -0,0 +1,13 @@
+// Svelte lifecycle wiring over `watchPowerState` from core, twin of upstream's `usePowerState`
+import { initialPowerState, watchPowerState, } from '../../core/index.js';
+export function usePowerState() {
+    let powerState = $state.raw(initialPowerState);
+    $effect(() => watchPowerState(next => {
+        powerState = next;
+    }));
+    return {
+        get current() {
+            return powerState;
+        },
+    };
+}

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

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

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

@@ -0,0 +1,16 @@
+// Vue lifecycle wiring over `watchPowerState` from core, twin of upstream's `usePowerState`
+import { onMounted, onUnmounted, shallowRef, } from '@vue/runtime-core';
+import { initialPowerState, watchPowerState, } from '../../../core/index.js';
+export function usePowerState() {
+    const powerState = shallowRef(initialPowerState);
+    let stop;
+    onMounted(() => {
+        stop = watchPowerState(next => {
+            powerState.value = next;
+        });
+    });
+    onUnmounted(() => {
+        stop?.();
+    });
+    return powerState;
+}

package/build/vue/index.d.ts

@@ -1,4 +1,5 @@
 export { useBatteryLevel } from './composables/use-battery-level';
 export { useBatteryState } from './composables/use-battery-state';
 export { useLowPowerMode } from './composables/use-low-power-mode';
+export { usePowerState } from './composables/use-power-state';
 export * from '../core';

package/build/vue/index.js

@@ -6,4 +6,5 @@
 export { useBatteryLevel } from './composables/use-battery-level/index.js';
 export { useBatteryState } from './composables/use-battery-state/index.js';
 export { useLowPowerMode } from './composables/use-low-power-mode/index.js';
+export { usePowerState } from './composables/use-power-state/index.js';
 export * from '../core/index.js';

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

@@ -1,4 +1,5 @@
 export { BatteryLevelService } from './services/battery-level.service';
 export { BatteryStateService } from './services/battery-state.service';
 export { LowPowerModeService } from './services/low-power-mode.service';
+export { PowerStateService } from './services/power-state.service';
 export * from '../core';

package/build-ngc/angular/index.js

@@ -5,5 +5,6 @@
 export { BatteryLevelService } from './services/battery-level.service';
 export { BatteryStateService } from './services/battery-state.service';
 export { LowPowerModeService } from './services/low-power-mode.service';
+export { PowerStateService } from './services/power-state.service';
 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,6FAA6F;AAC7F,yFAAyF;AACzF,yFAAyF;AACzF,8EAA8E;AAC9E,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AACxE,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,6FAA6F;AAC7F,yFAAyF;AACzF,yFAAyF;AACzF,8EAA8E;AAC9E,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AACxE,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,cAAc,SAAS,CAAC"}

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

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

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

@@ -0,0 +1,18 @@
+import { inject, Injectable, Injector } from '@angular/core';
+import { connectWatchedSignal } from '@symbiote-native/angular';
+import { initialPowerState, watchPowerState, } from '../../../core';
+import * as i0 from "@angular/core";
+// Angular twin of `usePowerState`, same `connect()` pattern as `BatteryLevelService`
+export class PowerStateService {
+    injector = inject(Injector);
+    connect() {
+        return connectWatchedSignal(this.injector, initialPowerState, watchPowerState);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: PowerStateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: PowerStateService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: PowerStateService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/angular/services/power-state.service/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAe,MAAM,eAAe,CAAC;AAC1E,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EACL,iBAAiB,EACjB,eAAe,GAEhB,MAAM,eAAe,CAAC;;AAEvB,qFAAqF;AAErF,MAAM,OAAO,iBAAiB;IACX,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;IAE7C,OAAO;QACL,OAAO,oBAAoB,CACzB,IAAI,CAAC,QAAQ,EACb,iBAAiB,EACjB,eAAe,CAChB,CAAC;IACJ,CAAC;uGATU,iBAAiB;2GAAjB,iBAAiB,cADJ,MAAM;;2FACnB,iBAAiB;kBAD7B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE"}

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

@@ -1,3 +1,4 @@
 export { isAvailableAsync, getBatteryLevelAsync, getBatteryStateAsync, isLowPowerModeEnabledAsync, isBatteryOptimizationEnabledAsync, getPowerStateAsync, addBatteryLevelListener, addBatteryStateListener, addLowPowerModeListener, } from './battery';
 export { BatteryState, type PowerState, type BatteryLevelEvent, type BatteryStateEvent, type PowerModeEvent, } from './types';
+export { initialPowerState, watchPowerState } from './power-state';
 export type { EventSubscription } from 'expo-modules-core';

package/build-ngc/core/index.js

@@ -1,3 +1,4 @@
 export { isAvailableAsync, getBatteryLevelAsync, getBatteryStateAsync, isLowPowerModeEnabledAsync, isBatteryOptimizationEnabledAsync, getPowerStateAsync, addBatteryLevelListener, addBatteryStateListener, addLowPowerModeListener, } from './battery';
 export { BatteryState, } from './types';
+export { initialPowerState, watchPowerState } from './power-state';
 //# sourceMappingURL=index.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACpB,oBAAoB,EACpB,0BAA0B,EAC1B,iCAAiC,EACjC,kBAAkB,EAClB,uBAAuB,EACvB,uBAAuB,EACvB,uBAAuB,GACxB,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,YAAY,GAKb,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,oBAAoB,EACpB,oBAAoB,EACpB,0BAA0B,EAC1B,iCAAiC,EACjC,kBAAkB,EAClB,uBAAuB,EACvB,uBAAuB,EACvB,uBAAuB,GACxB,MAAM,WAAW,CAAC;AACnB,OAAO,EACL,YAAY,GAKb,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC"}

package/build-ngc/core/power-state.d.ts

@@ -0,0 +1,3 @@
+import { type PowerState } from './types';
+export declare const initialPowerState: PowerState;
+export declare function watchPowerState(onChange: (state: PowerState) => void): () => void;

package/build-ngc/core/power-state.js

@@ -0,0 +1,38 @@
+// Shared half of upstream's `usePowerState`: level, state and low-power mode as one merged value
+import { addBatteryLevelListener, addBatteryStateListener, addLowPowerModeListener, getBatteryLevelAsync, getBatteryStateAsync, isLowPowerModeEnabledAsync, } from './battery';
+import { BatteryState } from './types';
+export const initialPowerState = {
+    lowPowerMode: false,
+    batteryLevel: -1,
+    batteryState: BatteryState.UNKNOWN,
+};
+// Seeds each field with a one-shot fetch, then follows native events; returns the teardown
+export function watchPowerState(onChange) {
+    let state = initialPowerState;
+    let isStopped = false;
+    const heardFields = new Set();
+    // A native event that lands before its seed resolves wins because the seed is the older value
+    function write(key, value, isSeed) {
+        if (isStopped || (isSeed && heardFields.has(key))) {
+            return;
+        }
+        if (!isSeed) {
+            heardFields.add(key);
+        }
+        state = { ...state, [key]: value };
+        onChange(state);
+    }
+    const subscriptions = [
+        addLowPowerModeListener(event => write('lowPowerMode', event.lowPowerMode, false)),
+        addBatteryLevelListener(event => write('batteryLevel', event.batteryLevel, false)),
+        addBatteryStateListener(event => write('batteryState', event.batteryState, false)),
+    ];
+    isLowPowerModeEnabledAsync().then(value => write('lowPowerMode', value, true));
+    getBatteryLevelAsync().then(value => write('batteryLevel', value, true));
+    getBatteryStateAsync().then(value => write('batteryState', value, true));
+    return () => {
+        isStopped = true;
+        subscriptions.forEach(subscription => subscription.remove());
+    };
+}
+//# sourceMappingURL=power-state.js.map

package/build-ngc/core/power-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"power-state.js","sourceRoot":"","sources":["../../src/core/power-state.ts"],"names":[],"mappings":"AAAA,iGAAiG;AACjG,OAAO,EACL,uBAAuB,EACvB,uBAAuB,EACvB,uBAAuB,EACvB,oBAAoB,EACpB,oBAAoB,EACpB,0BAA0B,GAC3B,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,YAAY,EAAmB,MAAM,SAAS,CAAC;AAExD,MAAM,CAAC,MAAM,iBAAiB,GAAe;IAC3C,YAAY,EAAE,KAAK;IACnB,YAAY,EAAE,CAAC,CAAC;IAChB,YAAY,EAAE,YAAY,CAAC,OAAO;CACnC,CAAC;AAEF,2FAA2F;AAC3F,MAAM,UAAU,eAAe,CAC7B,QAAqC;IAErC,IAAI,KAAK,GAAG,iBAAiB,CAAC;IAC9B,IAAI,SAAS,GAAG,KAAK,CAAC;IACtB,MAAM,WAAW,GAAG,IAAI,GAAG,EAAoB,CAAC;IAEhD,8FAA8F;IAC9F,SAAS,KAAK,CACZ,GAAM,EACN,KAAoB,EACpB,MAAe;QAEf,IAAI,SAAS,IAAI,CAAC,MAAM,IAAI,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;YAClD,OAAO;QACT,CAAC;QACD,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACvB,CAAC;QACD,KAAK,GAAG,EAAE,GAAG,KAAK,EAAE,CAAC,GAAG,CAAC,EAAE,KAAK,EAAE,CAAC;QACnC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAClB,CAAC;IAED,MAAM,aAAa,GAAG;QACpB,uBAAuB,CAAC,KAAK,CAAC,EAAE,CAC9B,KAAK,CAAC,cAAc,EAAE,KAAK,CAAC,YAAY,EAAE,KAAK,CAAC,CACjD;QACD,uBAAuB,CAAC,KAAK,CAAC,EAAE,CAC9B,KAAK,CAAC,cAAc,EAAE,KAAK,CAAC,YAAY,EAAE,KAAK,CAAC,CACjD;QACD,uBAAuB,CAAC,KAAK,CAAC,EAAE,CAC9B,KAAK,CAAC,cAAc,EAAE,KAAK,CAAC,YAAY,EAAE,KAAK,CAAC,CACjD;KACF,CAAC;IACF,0BAA0B,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CACxC,KAAK,CAAC,cAAc,EAAE,KAAK,EAAE,IAAI,CAAC,CACnC,CAAC;IACF,oBAAoB,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,cAAc,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;IACzE,oBAAoB,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,cAAc,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC;IAEzE,OAAO,GAAG,EAAE;QACV,SAAS,GAAG,IAAI,CAAC;QACjB,aAAa,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC;IAC/D,CAAC,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbiote-native/battery",
-  "version": "3.0.1",
+  "version": "3.0.3",
   "description": "expo-battery wrapped for SymbioteNative — one framework-agnostic core, built once and reachable from the React, Vue, Svelte, Solid, and Angular adapters. Battery level and state (charging/full/unplugged/unknown), low-power-mode detection, plus event listeners for level and state changes.",
   "license": "MIT",
   "repository": {
@@ -70,7 +70,7 @@
   },
   "dependencies": {
     "expo-battery": "57.0.1",
-    "expo-modules-core": "57.0.5"
+    "expo-modules-core": "57.0.20"
   },
   "peerDependencies": {
     "@angular/core": ">=20",
@@ -80,12 +80,12 @@
     "solid-js": ">=1.9.0",
     "svelte": ">=5.56.0",
     "vue": ">=3.5.0",
-    "@symbiote-native/angular": "^3.1.1",
-    "@symbiote-native/engine": "^1.3.0",
-    "@symbiote-native/react": "^3.0.3",
-    "@symbiote-native/solid": "^3.0.3",
-    "@symbiote-native/svelte": "^3.0.3",
-    "@symbiote-native/vue": "^3.0.3"
+    "@symbiote-native/angular": "^3.2.0",
+    "@symbiote-native/engine": "^1.5.0",
+    "@symbiote-native/react": "^3.2.0",
+    "@symbiote-native/solid": "^3.1.0",
+    "@symbiote-native/svelte": "^3.1.0",
+    "@symbiote-native/vue": "^3.2.0"
   },
   "peerDependenciesMeta": {
     "@symbiote-native/angular": {
@@ -133,13 +133,13 @@
     "solid-js": "^1.9.14",
     "svelte": "^5.56.0",
     "typescript": "~6.0.0",
-    "@symbiote-native/angular": "3.1.1",
-    "@symbiote-native/engine": "1.3.0",
-    "@symbiote-native/react": "3.0.3",
-    "@symbiote-native/solid": "3.0.3",
-    "@symbiote-native/svelte": "3.0.3",
-    "@symbiote-native/test-utils": "0.4.3",
-    "@symbiote-native/vue": "3.0.3"
+    "@symbiote-native/angular": "3.2.0",
+    "@symbiote-native/engine": "1.5.0",
+    "@symbiote-native/react": "3.2.0",
+    "@symbiote-native/solid": "3.1.0",
+    "@symbiote-native/svelte": "3.1.0",
+    "@symbiote-native/test-utils": "0.4.6",
+    "@symbiote-native/vue": "3.2.0"
   },
   "scripts": {
     "typecheck": "tsc --build",

package/src/angular/index.ts

@@ -5,4 +5,5 @@
 export { BatteryLevelService } from './services/battery-level.service';
 export { BatteryStateService } from './services/battery-state.service';
 export { LowPowerModeService } from './services/low-power-mode.service';
+export { PowerStateService } from './services/power-state.service';
 export * from '../core';

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

@@ -0,0 +1,21 @@
+import { inject, Injectable, Injector, type Signal } from '@angular/core';
+import { connectWatchedSignal } from '@symbiote-native/angular';
+import {
+  initialPowerState,
+  watchPowerState,
+  type PowerState,
+} from '../../../core';
+
+// Angular twin of `usePowerState`, same `connect()` pattern as `BatteryLevelService`
+@Injectable({ providedIn: 'root' })
+export class PowerStateService {
+  private readonly injector = inject(Injector);
+
+  connect(): Signal<PowerState> {
+    return connectWatchedSignal(
+      this.injector,
+      initialPowerState,
+      watchPowerState,
+    );
+  }
+}

package/src/core/index.ts

@@ -16,4 +16,5 @@ export {
   type BatteryStateEvent,
   type PowerModeEvent,
 } from './types';
+export { initialPowerState, watchPowerState } from './power-state';
 export type { EventSubscription } from 'expo-modules-core';

package/src/core/power-state.ts

@@ -0,0 +1,63 @@
+// Shared half of upstream's `usePowerState`: level, state and low-power mode as one merged value
+import {
+  addBatteryLevelListener,
+  addBatteryStateListener,
+  addLowPowerModeListener,
+  getBatteryLevelAsync,
+  getBatteryStateAsync,
+  isLowPowerModeEnabledAsync,
+} from './battery';
+import { BatteryState, type PowerState } from './types';
+
+export const initialPowerState: PowerState = {
+  lowPowerMode: false,
+  batteryLevel: -1,
+  batteryState: BatteryState.UNKNOWN,
+};
+
+// Seeds each field with a one-shot fetch, then follows native events; returns the teardown
+export function watchPowerState(
+  onChange: (state: PowerState) => void,
+): () => void {
+  let state = initialPowerState;
+  let isStopped = false;
+  const heardFields = new Set<keyof PowerState>();
+
+  // A native event that lands before its seed resolves wins because the seed is the older value
+  function write<K extends keyof PowerState>(
+    key: K,
+    value: PowerState[K],
+    isSeed: boolean,
+  ): void {
+    if (isStopped || (isSeed && heardFields.has(key))) {
+      return;
+    }
+    if (!isSeed) {
+      heardFields.add(key);
+    }
+    state = { ...state, [key]: value };
+    onChange(state);
+  }
+
+  const subscriptions = [
+    addLowPowerModeListener(event =>
+      write('lowPowerMode', event.lowPowerMode, false),
+    ),
+    addBatteryLevelListener(event =>
+      write('batteryLevel', event.batteryLevel, false),
+    ),
+    addBatteryStateListener(event =>
+      write('batteryState', event.batteryState, false),
+    ),
+  ];
+  isLowPowerModeEnabledAsync().then(value =>
+    write('lowPowerMode', value, true),
+  );
+  getBatteryLevelAsync().then(value => write('batteryLevel', value, true));
+  getBatteryStateAsync().then(value => write('batteryState', value, true));
+
+  return () => {
+    isStopped = true;
+    subscriptions.forEach(subscription => subscription.remove());
+  };
+}

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

@@ -0,0 +1,15 @@
+// React lifecycle wiring over `watchPowerState` from core, twin of upstream's `usePowerState`
+import { useEffect, useState } from 'react';
+import {
+  initialPowerState,
+  watchPowerState,
+  type PowerState,
+} from '../../../core';
+
+export function usePowerState(): PowerState {
+  const [powerState, setPowerState] = useState(initialPowerState);
+
+  useEffect(() => watchPowerState(setPowerState), []);
+
+  return powerState;
+}

package/src/react/index.ts

@@ -7,4 +7,5 @@
 export { useBatteryLevel } from './hooks/use-battery-level';
 export { useBatteryState } from './hooks/use-battery-state';
 export { useLowPowerMode } from './hooks/use-low-power-mode';
+export { usePowerState } from './hooks/use-power-state';
 export * from '../core';

package/src/solid/index.ts

@@ -8,4 +8,5 @@
 export { createBatteryLevel } from './primitives/create-battery-level';
 export { createBatteryState } from './primitives/create-battery-state';
 export { createLowPowerMode } from './primitives/create-low-power-mode';
+export { createPowerState } from './primitives/create-power-state';
 export * from '../core';

package/src/solid/primitives/create-power-state.ts

@@ -0,0 +1,15 @@
+// Solid lifecycle wiring over `watchPowerState` from core, twin of upstream's `usePowerState`
+import { createSignal, onCleanup, type Accessor } from 'solid-js';
+import {
+  initialPowerState,
+  watchPowerState,
+  type PowerState,
+} from '../../core';
+
+export function createPowerState(): Accessor<PowerState> {
+  const [powerState, setPowerState] = createSignal(initialPowerState);
+
+  onCleanup(watchPowerState(setPowerState));
+
+  return powerState;
+}

package/src/svelte/index.ts

@@ -7,4 +7,5 @@
 export { useBatteryLevel } from './runes/use-battery-level.svelte';
 export { useBatteryState } from './runes/use-battery-state.svelte';
 export { useLowPowerMode } from './runes/use-low-power-mode.svelte';
+export { usePowerState } from './runes/use-power-state.svelte';
 export * from '../core';

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

@@ -0,0 +1,22 @@
+// Svelte lifecycle wiring over `watchPowerState` from core, twin of upstream's `usePowerState`
+import {
+  initialPowerState,
+  watchPowerState,
+  type PowerState,
+} from '../../core';
+
+export function usePowerState(): { readonly current: PowerState } {
+  let powerState = $state.raw(initialPowerState);
+
+  $effect(() =>
+    watchPowerState(next => {
+      powerState = next;
+    }),
+  );
+
+  return {
+    get current(): PowerState {
+      return powerState;
+    },
+  };
+}

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

@@ -0,0 +1,29 @@
+// Vue lifecycle wiring over `watchPowerState` from core, twin of upstream's `usePowerState`
+import {
+  onMounted,
+  onUnmounted,
+  shallowRef,
+  type Ref,
+} from '@vue/runtime-core';
+import {
+  initialPowerState,
+  watchPowerState,
+  type PowerState,
+} from '../../../core';
+
+export function usePowerState(): Ref<PowerState> {
+  const powerState = shallowRef(initialPowerState);
+  let stop: (() => void) | undefined;
+
+  onMounted(() => {
+    stop = watchPowerState(next => {
+      powerState.value = next;
+    });
+  });
+
+  onUnmounted(() => {
+    stop?.();
+  });
+
+  return powerState;
+}

package/src/vue/index.ts

@@ -7,4 +7,5 @@
 export { useBatteryLevel } from './composables/use-battery-level';
 export { useBatteryState } from './composables/use-battery-state';
 export { useLowPowerMode } from './composables/use-low-power-mode';
+export { usePowerState } from './composables/use-power-state';
 export * from '../core';