@symbiote-native/battery 0.0.1 → 0.1.0

package/build-ngc/core/types.js

@@ -0,0 +1,24 @@
+// Hand-ported from .vendors/expo/packages/expo-battery/src/Battery.types.ts (sdk-57) — plain
+// data shapes, no `expo` meta-package import to swap out (unlike local-auth's types.ts).
+export var BatteryState;
+(function (BatteryState) {
+    /** If the battery state is unknown or inaccessible. */
+    BatteryState[BatteryState["UNKNOWN"] = 0] = "UNKNOWN";
+    /**
+     * If the battery is discharging (typically not connected to power). On Android, this
+     * corresponds to `BATTERY_STATUS_DISCHARGING`.
+     */
+    BatteryState[BatteryState["UNPLUGGED"] = 1] = "UNPLUGGED";
+    /** If battery is charging. */
+    BatteryState[BatteryState["CHARGING"] = 2] = "CHARGING";
+    /** If the battery level is full. */
+    BatteryState[BatteryState["FULL"] = 3] = "FULL";
+    /**
+     * The battery is not charging while power is connected (AC/USB/wireless), for example when
+     * battery protection limits charge to 80%, or optimized charging pauses. This differs from
+     * `UNPLUGGED` (discharging on battery).
+     * @platform android
+     */
+    BatteryState[BatteryState["NOT_CHARGING"] = 4] = "NOT_CHARGING";
+})(BatteryState || (BatteryState = {}));
+//# sourceMappingURL=types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"AAAA,6FAA6F;AAC7F,yFAAyF;AAWzF,MAAM,CAAN,IAAY,YAmBX;AAnBD,WAAY,YAAY;IACtB,uDAAuD;IACvD,qDAAW,CAAA;IACX;;;OAGG;IACH,yDAAS,CAAA;IACT,8BAA8B;IAC9B,uDAAQ,CAAA;IACR,oCAAoC;IACpC,+CAAI,CAAA;IACJ;;;;;OAKG;IACH,+DAAY,CAAA;AACd,CAAC,EAnBW,YAAY,KAAZ,YAAY,QAmBvB"}

package/native-link.json

@@ -0,0 +1,12 @@
+{
+  "android": {
+    "gradleProjectName": "expo-battery",
+    "modules": [
+      {
+        "importPath": "expo.modules.battery.BatteryModule",
+        "className": "BatteryModule",
+        "nativeName": "ExpoBattery"
+      }
+    ]
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbiote-native/battery",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "description": "expo-battery wrapped for SymbioteNative — one framework-agnostic core, built once and reachable from the React, Vue, 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": {
@@ -13,7 +13,98 @@
     "url": "https://github.com/OneEyed1366/symbiote-native/issues"
   },
   "author": "Andrey Prokopenko <psevdoproger@gmail.com>",
+  "type": "module",
+  "main": "./build/core/index.js",
+  "module": "./build/core/index.js",
+  "types": "./build/core/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/core/index.d.ts",
+      "default": "./build/core/index.js"
+    },
+    "./vue": {
+      "types": "./build/vue/index.d.ts",
+      "default": "./build/vue/index.js"
+    },
+    "./react": {
+      "types": "./build/react/index.d.ts",
+      "default": "./build/react/index.js"
+    },
+    "./angular": {
+      "types": "./build-ngc/angular/index.d.ts",
+      "react-native": "./build-ngc/angular/index.js",
+      "default": "./src/angular/index.ts"
+    }
+  },
+  "files": [
+    "src",
+    "build",
+    "build-ngc",
+    "native-link.json",
+    "!src/**/*.test.*",
+    "!src/**/*.spec.*",
+    "!src/**/*.detox.*"
+  ],
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "expo-battery": "57.0.1",
+    "expo-modules-core": "57.0.5"
+  },
+  "peerDependencies": {
+    "@symbiote-native/engine": ">=0.1.7",
+    "@angular/core": ">=20",
+    "@vue/runtime-core": "^3.5.13",
+    "react": ">=19.0.0",
+    "react-native": ">=0.86",
+    "vue": ">=3.5.0",
+    "@symbiote-native/angular": "0.6.2",
+    "@symbiote-native/react": "0.2.8",
+    "@symbiote-native/vue": "0.3.8"
+  },
+  "peerDependenciesMeta": {
+    "@symbiote-native/angular": {
+      "optional": true
+    },
+    "@symbiote-native/react": {
+      "optional": true
+    },
+    "@symbiote-native/vue": {
+      "optional": true
+    },
+    "@angular/core": {
+      "optional": true
+    },
+    "@vue/runtime-core": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@angular/compiler": "^22",
+    "@angular/compiler-cli": "^22",
+    "@angular/core": "^22",
+    "@types/node": "^26.0.0",
+    "@types/react": "^19.2.0",
+    "@vue/runtime-core": "^3.5.13",
+    "react": "19.2.3",
+    "typescript": "~6.0.0",
+    "@symbiote-native/angular": "0.6.2",
+    "@symbiote-native/engine": "0.1.7",
+    "@symbiote-native/react": "0.2.8",
+    "@symbiote-native/test-utils": "0.1.6",
+    "@symbiote-native/vue": "0.3.8"
+  },
+  "scripts": {
+    "typecheck": "tsc --build",
+    "clean": "rm -rf build-ngc",
+    "ng:build": "pnpm run clean && ngc -p tsconfig.angular.json",
+    "format": "prettier --write \"src/**/*.{ts,tsx}\""
   }
 }

package/src/angular/index.ts

@@ -0,0 +1,24 @@
+// BatteryLevelService/BatteryStateService/LowPowerModeService are the Angular-only lifecycle
+// half; the free functions and event subscription plumbing all live in core, shared with
+// React/Vue. Three separate services (not one combined service), matching upstream's own
+// useBatteryLevel/useBatteryState/useLowPowerMode being three separate hooks.
+export { BatteryLevelService } from './services/battery-level.service';
+export { BatteryStateService } from './services/battery-state.service';
+export { LowPowerModeService } from './services/low-power-mode.service';
+export {
+  isAvailableAsync,
+  getBatteryLevelAsync,
+  getBatteryStateAsync,
+  isLowPowerModeEnabledAsync,
+  isBatteryOptimizationEnabledAsync,
+  getPowerStateAsync,
+  addBatteryLevelListener,
+  addBatteryStateListener,
+  addLowPowerModeListener,
+  BatteryState,
+  type PowerState,
+  type BatteryLevelEvent,
+  type BatteryStateEvent,
+  type PowerModeEvent,
+  type EventSubscription,
+} from '../core';

package/src/angular/services/battery-level.service/index.ts

@@ -0,0 +1,32 @@
+import { effect, inject, Injectable, Injector, signal, type Signal } from '@angular/core';
+import { addBatteryLevelListener, getBatteryLevelAsync } from '../../../core';
+
+// Angular twin of React's `useBatteryLevel` hook and Vue's `useBatteryLevel` composable.
+// Angular has no per-instance hook — state and lifecycle live in DI instead, so `connect()`
+// stands in for the hook's role: call it ONCE (typically from a component's field initializer,
+// inside an injection context).
+//
+//   readonly batteryLevel = inject(BatteryLevelService).connect();
+//   // template: {{ batteryLevel() }}
+//
+// Mirrors AccelerometerService.connect() — a single effect() that seeds the initial value with
+// getBatteryLevelAsync(), subscribes once, and cleans up once.
+@Injectable({ providedIn: 'root' })
+export class BatteryLevelService {
+  private readonly injector = inject(Injector);
+
+  connect(): Signal<number> {
+    const batteryLevel = signal(-1);
+
+    effect(
+      onCleanup => {
+        getBatteryLevelAsync().then(level => batteryLevel.set(level));
+        const subscription = addBatteryLevelListener(event => batteryLevel.set(event.batteryLevel));
+        onCleanup(() => subscription.remove());
+      },
+      { injector: this.injector },
+    );
+
+    return batteryLevel.asReadonly();
+  }
+}

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

@@ -0,0 +1,27 @@
+import { effect, inject, Injectable, Injector, signal, type Signal } from '@angular/core';
+import { addBatteryStateListener, BatteryState, getBatteryStateAsync } from '../../../core';
+
+// Angular twin of React's `useBatteryState` hook and Vue's `useBatteryState` composable. See
+// BatteryLevelService for the `connect()` pattern rationale.
+//
+//   readonly batteryState = inject(BatteryStateService).connect();
+//   // template: {{ batteryState() }}
+@Injectable({ providedIn: 'root' })
+export class BatteryStateService {
+  private readonly injector = inject(Injector);
+
+  connect(): Signal<BatteryState> {
+    const batteryState = signal<BatteryState>(BatteryState.UNKNOWN);
+
+    effect(
+      onCleanup => {
+        getBatteryStateAsync().then(state => batteryState.set(state));
+        const subscription = addBatteryStateListener(event => batteryState.set(event.batteryState));
+        onCleanup(() => subscription.remove());
+      },
+      { injector: this.injector },
+    );
+
+    return batteryState.asReadonly();
+  }
+}

package/src/angular/services/low-power-mode.service/index.ts

@@ -0,0 +1,27 @@
+import { effect, inject, Injectable, Injector, signal, type Signal } from '@angular/core';
+import { addLowPowerModeListener, isLowPowerModeEnabledAsync } from '../../../core';
+
+// Angular twin of React's `useLowPowerMode` hook and Vue's `useLowPowerMode` composable. See
+// BatteryLevelService for the `connect()` pattern rationale.
+//
+//   readonly lowPowerMode = inject(LowPowerModeService).connect();
+//   // template: {{ lowPowerMode() }}
+@Injectable({ providedIn: 'root' })
+export class LowPowerModeService {
+  private readonly injector = inject(Injector);
+
+  connect(): Signal<boolean> {
+    const lowPowerMode = signal(false);
+
+    effect(
+      onCleanup => {
+        isLowPowerModeEnabledAsync().then(enabled => lowPowerMode.set(enabled));
+        const subscription = addLowPowerModeListener(event => lowPowerMode.set(event.lowPowerMode));
+        onCleanup(() => subscription.remove());
+      },
+      { injector: this.injector },
+    );
+
+    return lowPowerMode.asReadonly();
+  }
+}

package/src/core/battery.ts

@@ -0,0 +1,105 @@
+// Hand-ported from .vendors/expo/packages/expo-battery/src/Battery.ts (sdk-57). Unlike
+// local-auth/pedometer, upstream Battery never throws UnavailabilityError — every function
+// falls back to a documented sentinel (-1 / BatteryState.UNKNOWN / false) when the native
+// method is absent, so that fallback shape is preserved here verbatim rather than guessed.
+import type { EventSubscription } from 'expo-modules-core';
+import { expoBattery } from './native-module';
+import {
+  BatteryState,
+  type BatteryLevelEvent,
+  type BatteryStateEvent,
+  type PowerModeEvent,
+  type PowerState,
+} from './types';
+
+/**
+ * Resolves with whether the battery API is available on the current device. `true` on Android
+ * and physical iOS devices, `false` on iOS simulators.
+ */
+export async function isAvailableAsync(): Promise<boolean> {
+  return Promise.resolve((expoBattery && expoBattery.isSupported) || false);
+}
+
+/**
+ * Gets the battery level of the device as a number between `0` and `1`, inclusive. If the
+ * device does not support retrieving the battery level, this method returns `-1`.
+ */
+export async function getBatteryLevelAsync(): Promise<number> {
+  if (!expoBattery.getBatteryLevelAsync) {
+    return -1;
+  }
+  return expoBattery.getBatteryLevelAsync();
+}
+
+/** Tells the battery's current state. */
+export async function getBatteryStateAsync(): Promise<BatteryState> {
+  if (!expoBattery.getBatteryStateAsync) {
+    return BatteryState.UNKNOWN;
+  }
+  return expoBattery.getBatteryStateAsync();
+}
+
+/**
+ * Gets the current status of Power Saver mode on Android and Low Power mode on iOS. If a
+ * platform doesn't support low-power-mode reporting, this always resolves `false`, even if the
+ * device is actually in low-power mode.
+ */
+export async function isLowPowerModeEnabledAsync(): Promise<boolean> {
+  if (!expoBattery.isLowPowerModeEnabledAsync) {
+    return false;
+  }
+  return expoBattery.isLowPowerModeEnabledAsync();
+}
+
+/**
+ * Checks whether battery optimization is enabled for this app. If enabled, background tasks
+ * might be affected when the app goes into doze mode state.
+ * @platform android
+ */
+export async function isBatteryOptimizationEnabledAsync(): Promise<boolean> {
+  if (!expoBattery.isBatteryOptimizationEnabledAsync) {
+    return false;
+  }
+  return expoBattery.isBatteryOptimizationEnabledAsync();
+}
+
+/**
+ * Gets the power state of the device: battery level, whether it is plugged in, and whether the
+ * system is currently in Power Saver Mode (Android) / Low Power Mode (iOS).
+ */
+export async function getPowerStateAsync(): Promise<PowerState> {
+  const [batteryLevel, batteryState, lowPowerMode] = await Promise.all([
+    getBatteryLevelAsync(),
+    getBatteryStateAsync(),
+    isLowPowerModeEnabledAsync(),
+  ]);
+  return { batteryLevel, batteryState, lowPowerMode };
+}
+
+/**
+ * Subscribe to battery level change updates. On Android this only fires on significant changes
+ * (crossing the low/okay battery thresholds); on iOS it fires per one-percent drop, at most once
+ * a minute.
+ */
+export function addBatteryLevelListener(
+  listener: (event: BatteryLevelEvent) => void,
+): EventSubscription {
+  return expoBattery.addListener('Expo.batteryLevelDidChange', listener);
+}
+
+/** Subscribe to battery state (charging/full/unplugged/unknown) change updates. */
+export function addBatteryStateListener(
+  listener: (event: BatteryStateEvent) => void,
+): EventSubscription {
+  return expoBattery.addListener('Expo.batteryStateDidChange', listener);
+}
+
+/**
+ * Subscribe to Power Saver Mode (Android) / Low Power Mode (iOS) updates. Fires whenever the
+ * power mode is toggled.
+ */
+export function addLowPowerModeListener(
+  listener: (event: PowerModeEvent) => void,
+): EventSubscription {
+  return expoBattery.addListener('Expo.powerModeDidChange', listener);
+}

package/src/core/index.ts

@@ -0,0 +1,19 @@
+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 type { EventSubscription } from 'expo-modules-core';

package/src/core/native-module.ts

@@ -0,0 +1,31 @@
+import { requireNativeModule } from 'expo-modules-core';
+import type { EventSubscription } from 'expo-modules-core';
+import type { BatteryLevelEvent, BatteryState, BatteryStateEvent, PowerModeEvent } from './types';
+
+const EXPO_BATTERY_MODULE_NAME = 'ExpoBattery';
+
+// Upstream's own event names, verified against .vendors/expo/packages/expo-battery/src/Battery.ts
+// (sdk-57) — a single native module fans out three distinct event shapes through one
+// `addListener`, so the overloads below key the payload type off the literal event name, the
+// same trick TypeScript uses for DOM's `addEventListener`.
+export type INativeBatteryModule = {
+  isSupported?: boolean;
+  getBatteryLevelAsync?(): Promise<number>;
+  getBatteryStateAsync?(): Promise<BatteryState>;
+  isLowPowerModeEnabledAsync?(): Promise<boolean>;
+  isBatteryOptimizationEnabledAsync?(): Promise<boolean>;
+  addListener(
+    eventName: 'Expo.batteryLevelDidChange',
+    listener: (event: BatteryLevelEvent) => void,
+  ): EventSubscription;
+  addListener(
+    eventName: 'Expo.batteryStateDidChange',
+    listener: (event: BatteryStateEvent) => void,
+  ): EventSubscription;
+  addListener(
+    eventName: 'Expo.powerModeDidChange',
+    listener: (event: PowerModeEvent) => void,
+  ): EventSubscription;
+};
+
+export const expoBattery = requireNativeModule<INativeBatteryModule>(EXPO_BATTERY_MODULE_NAME);

package/src/core/types.ts

@@ -0,0 +1,47 @@
+// Hand-ported from .vendors/expo/packages/expo-battery/src/Battery.types.ts (sdk-57) — plain
+// data shapes, no `expo` meta-package import to swap out (unlike local-auth's types.ts).
+
+export type PowerState = {
+  /** A number between `0` and `1`, inclusive, or `-1` if the battery level is unknown. */
+  batteryLevel: number;
+  /** An enum value representing the battery state. */
+  batteryState: BatteryState;
+  /** `true` if lowPowerMode is on, `false` if lowPowerMode is off. */
+  lowPowerMode: boolean;
+};
+
+export enum BatteryState {
+  /** If the battery state is unknown or inaccessible. */
+  UNKNOWN = 0,
+  /**
+   * If the battery is discharging (typically not connected to power). On Android, this
+   * corresponds to `BATTERY_STATUS_DISCHARGING`.
+   */
+  UNPLUGGED,
+  /** If battery is charging. */
+  CHARGING,
+  /** If the battery level is full. */
+  FULL,
+  /**
+   * The battery is not charging while power is connected (AC/USB/wireless), for example when
+   * battery protection limits charge to 80%, or optimized charging pauses. This differs from
+   * `UNPLUGGED` (discharging on battery).
+   * @platform android
+   */
+  NOT_CHARGING,
+}
+
+export type BatteryLevelEvent = {
+  /** A number between `0` and `1`, inclusive, or `-1` if the battery level is unknown. */
+  batteryLevel: number;
+};
+
+export type BatteryStateEvent = {
+  /** An enum value representing the battery state. */
+  batteryState: BatteryState;
+};
+
+export type PowerModeEvent = {
+  /** `true` if lowPowerMode is on, `false` if lowPowerMode is off. */
+  lowPowerMode: boolean;
+};

package/src/react/hooks/use-battery-level/index.ts

@@ -0,0 +1,19 @@
+// React lifecycle wiring over the framework-agnostic core (core/battery.ts) — mirrors the
+// lifecycle-bucket naming convention of adapters/react/src/hooks and the shape of
+// packages/sensors/src/react/hooks/use-accelerometer. Seeds the initial value with a one-shot
+// getBatteryLevelAsync() call before the first native event fires, matching upstream's own
+// useBatteryLevel (.vendors/expo/packages/expo-battery/src/Battery.ts).
+import { useEffect, useState } from 'react';
+import { addBatteryLevelListener, getBatteryLevelAsync } from '../../../core';
+
+export function useBatteryLevel(): number {
+  const [batteryLevel, setBatteryLevel] = useState(-1);
+
+  useEffect(() => {
+    getBatteryLevelAsync().then(setBatteryLevel);
+    const subscription = addBatteryLevelListener(event => setBatteryLevel(event.batteryLevel));
+    return () => subscription.remove();
+  }, []);
+
+  return batteryLevel;
+}

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

@@ -0,0 +1,17 @@
+// React lifecycle wiring over the framework-agnostic core (core/battery.ts) — mirrors
+// use-battery-level's shape. Seeds the initial value with a one-shot getBatteryStateAsync()
+// call before the first native event fires, matching upstream's own useBatteryState.
+import { useEffect, useState } from 'react';
+import { addBatteryStateListener, BatteryState, getBatteryStateAsync } from '../../../core';
+
+export function useBatteryState(): BatteryState {
+  const [batteryState, setBatteryState] = useState<BatteryState>(BatteryState.UNKNOWN);
+
+  useEffect(() => {
+    getBatteryStateAsync().then(setBatteryState);
+    const subscription = addBatteryStateListener(event => setBatteryState(event.batteryState));
+    return () => subscription.remove();
+  }, []);
+
+  return batteryState;
+}

package/src/react/hooks/use-low-power-mode/index.ts

@@ -0,0 +1,18 @@
+// React lifecycle wiring over the framework-agnostic core (core/battery.ts) — mirrors
+// use-battery-level's shape. Seeds the initial value with a one-shot
+// isLowPowerModeEnabledAsync() call before the first native event fires, matching upstream's
+// own useLowPowerMode.
+import { useEffect, useState } from 'react';
+import { addLowPowerModeListener, isLowPowerModeEnabledAsync } from '../../../core';
+
+export function useLowPowerMode(): boolean {
+  const [lowPowerMode, setLowPowerMode] = useState(false);
+
+  useEffect(() => {
+    isLowPowerModeEnabledAsync().then(setLowPowerMode);
+    const subscription = addLowPowerModeListener(event => setLowPowerMode(event.lowPowerMode));
+    return () => subscription.remove();
+  }, []);
+
+  return lowPowerMode;
+}

package/src/react/index.ts

@@ -0,0 +1,26 @@
+// @symbiote-native/battery/react: the React entry over the framework-agnostic core. Battery's
+// three subscription-backed values (level/state/low-power-mode) each get their own lifecycle
+// hook, matching upstream's own useBatteryLevel/useBatteryState/useLowPowerMode being three
+// separate hooks, not one combined hook — mirrors the lifecycle-bucket naming convention of
+// adapters/react/src/hooks (never `composables`, that's Vue's term).
+
+export { useBatteryLevel } from './hooks/use-battery-level';
+export { useBatteryState } from './hooks/use-battery-state';
+export { useLowPowerMode } from './hooks/use-low-power-mode';
+export {
+  isAvailableAsync,
+  getBatteryLevelAsync,
+  getBatteryStateAsync,
+  isLowPowerModeEnabledAsync,
+  isBatteryOptimizationEnabledAsync,
+  getPowerStateAsync,
+  addBatteryLevelListener,
+  addBatteryStateListener,
+  addLowPowerModeListener,
+  BatteryState,
+  type PowerState,
+  type BatteryLevelEvent,
+  type BatteryStateEvent,
+  type PowerModeEvent,
+  type EventSubscription,
+} from '../core';

package/src/vue/composables/use-battery-level/index.ts

@@ -0,0 +1,32 @@
+// Vue lifecycle wiring over the framework-agnostic core (core/battery.ts) — mirrors the
+// lifecycle-bucket naming convention of adapters/vue/src/composables and the
+// onMounted/onUnmounted shape of packages/sensors/src/vue/composables/use-accelerometer. Seeds
+// the initial value with a one-shot getBatteryLevelAsync() call before the first native event
+// fires, matching upstream's own useBatteryLevel.
+
+import { onMounted, onUnmounted, ref, type Ref } from '@vue/runtime-core';
+import {
+  addBatteryLevelListener,
+  getBatteryLevelAsync,
+  type EventSubscription,
+} from '../../../core';
+
+export function useBatteryLevel(): Ref<number> {
+  const batteryLevel = ref(-1);
+  let subscription: EventSubscription | undefined;
+
+  onMounted(() => {
+    getBatteryLevelAsync().then(level => {
+      batteryLevel.value = level;
+    });
+    subscription = addBatteryLevelListener(event => {
+      batteryLevel.value = event.batteryLevel;
+    });
+  });
+
+  onUnmounted(() => {
+    subscription?.remove();
+  });
+
+  return batteryLevel;
+}

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

@@ -0,0 +1,31 @@
+// Vue lifecycle wiring over the framework-agnostic core (core/battery.ts) — mirrors
+// use-battery-level's shape. Seeds the initial value with a one-shot getBatteryStateAsync()
+// call before the first native event fires, matching upstream's own useBatteryState.
+
+import { onMounted, onUnmounted, ref, type Ref } from '@vue/runtime-core';
+import {
+  addBatteryStateListener,
+  BatteryState,
+  getBatteryStateAsync,
+  type EventSubscription,
+} from '../../../core';
+
+export function useBatteryState(): Ref<BatteryState> {
+  const batteryState = ref<BatteryState>(BatteryState.UNKNOWN);
+  let subscription: EventSubscription | undefined;
+
+  onMounted(() => {
+    getBatteryStateAsync().then(state => {
+      batteryState.value = state;
+    });
+    subscription = addBatteryStateListener(event => {
+      batteryState.value = event.batteryState;
+    });
+  });
+
+  onUnmounted(() => {
+    subscription?.remove();
+  });
+
+  return batteryState;
+}

package/src/vue/composables/use-low-power-mode/index.ts

@@ -0,0 +1,31 @@
+// Vue lifecycle wiring over the framework-agnostic core (core/battery.ts) — mirrors
+// use-battery-level's shape. Seeds the initial value with a one-shot
+// isLowPowerModeEnabledAsync() call before the first native event fires, matching upstream's
+// own useLowPowerMode.
+
+import { onMounted, onUnmounted, ref, type Ref } from '@vue/runtime-core';
+import {
+  addLowPowerModeListener,
+  isLowPowerModeEnabledAsync,
+  type EventSubscription,
+} from '../../../core';
+
+export function useLowPowerMode(): Ref<boolean> {
+  const lowPowerMode = ref(false);
+  let subscription: EventSubscription | undefined;
+
+  onMounted(() => {
+    isLowPowerModeEnabledAsync().then(enabled => {
+      lowPowerMode.value = enabled;
+    });
+    subscription = addLowPowerModeListener(event => {
+      lowPowerMode.value = event.lowPowerMode;
+    });
+  });
+
+  onUnmounted(() => {
+    subscription?.remove();
+  });
+
+  return lowPowerMode;
+}