@symbiote-native/battery 0.0.1 → 0.1.0

package/README.md

@@ -1,19 +1,144 @@
 # @symbiote-native/battery
 
-**Status: skeleton only — not implemented, published early to reserve the npm name.**
-This package currently ships nothing but `package.json` and this README. No `src/`, no
-dependencies, no build. See the `symbiote-new-package-skeleton` project skill for what a
-tier-1 skeleton package is and isn't.
-
-Planned: a port of [`expo-battery`](https://docs.expo.dev/versions/latest/sdk/battery/) for
+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
 from every adapter (React, Vue, Angular), not just React.
 
-## Planned API
+Built the same way as [`@symbiote-native/local-auth`](../local-auth) and
+[`@symbiote-native/sensors`](../sensors), an `expo-modules-core`-based wrapper (see the
+`symbiote-expo-native-module` project skill for the full mechanism: why `expo-modules-core` is
+depended on directly and never the `expo` meta-package, why the upstream JS is hand-ported into
+`core/` rather than imported, and how autolinking picks up the native module).
+
+## Install
+
+```bash
+npm install @symbiote-native/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
+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
+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
+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) |
+
+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`.
+
+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.
+                        native-module.ts resolves the native module through expo-modules-core's
+                        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/angular/services/   @symbiote-native/battery/angular — BatteryLevelService, BatteryStateService,
+                        LowPowerModeService (`.connect()` returns a Signal)
+```
+
+Each adapter's hook/composable/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 by all
+three.
+
+## Use it
+
+```tsx
+// React — examples/expo-react/screens/BatteryScreen.tsx
+import { useBatteryLevel, useBatteryState, useLowPowerMode } from '@symbiote-native/battery/react';
+import { BatteryState } from '@symbiote-native/battery';
+
+function BatteryScreen() {
+  const batteryLevel = useBatteryLevel();   // number, -1 until the first reading arrives
+  const batteryState = useBatteryState();   // BatteryState, UNKNOWN until the first reading
+  const lowPowerMode = useLowPowerMode();   // boolean, false until the first reading
+
+  const batteryLevelLabel = batteryLevel < 0 ? 'unknown' : `${Math.round(batteryLevel * 100)}%`;
+
+  return (
+    <>
+      <Text>{batteryLevelLabel}</Text>
+      <Text>{batteryState === BatteryState.CHARGING ? 'Charging' : 'Not charging'}</Text>
+      <Text>{lowPowerMode ? 'On' : 'Off'}</Text>
+    </>
+  );
+}
+```
+
+```vue
+<!-- Vue — examples/expo-vue-sfc/screens/BatteryScreen.vue -->
+<script setup lang="ts">
+import { computed } from 'vue';
+import { useBatteryLevel, useBatteryState, useLowPowerMode } from '@symbiote-native/battery/vue';
+
+const batteryLevel = useBatteryLevel(); // Ref<number>
+const batteryState = useBatteryState(); // Ref<BatteryState>
+const lowPowerMode = useLowPowerMode(); // Ref<boolean>
+
+const batteryLevelText = computed(() =>
+  batteryLevel.value < 0 ? 'unknown' : `${Math.round(batteryLevel.value * 100)}%`,
+);
+</script>
+<template>
+  <Text>{{ batteryLevelText }}</Text>
+  <Text>{{ lowPowerMode ? 'ON' : 'OFF' }}</Text>
+</template>
+```
+
+```ts
+// Angular — examples/expo-angular/src/screens/BatteryScreen.ts
+import { Component, inject } from '@angular/core';
+import { BatteryLevelService, BatteryStateService, LowPowerModeService } from '@symbiote-native/battery/angular';
+
+@Component({ /* ... */ })
+export class BatteryScreen {
+  readonly batteryLevel = inject(BatteryLevelService).connect();  // Signal<number>
+  readonly batteryState = inject(BatteryStateService).connect();  // Signal<BatteryState>
+  readonly lowPowerMode = inject(LowPowerModeService).connect();  // Signal<boolean>
+
+  batteryLevelLabel(): string {
+    const level = this.batteryLevel();
+    return level < 0 ? 'unknown' : `${Math.round(level * 100)}%`;
+  }
+}
+```
 
-Forward-looking reference only, transcribed from upstream's actual
-`.vendors/expo/packages/expo-battery/src/Battery.ts` — signatures here are what will be ported,
-not yet implemented.
+Each of the three 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.
+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.
+
+## API
+
+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.
 
 ```ts
 isAvailableAsync(): Promise<boolean>                          // battery API availability on this device
@@ -22,23 +147,43 @@ getBatteryStateAsync(): Promise<BatteryState>                 // UNKNOWN/UNPLUGG
 isLowPowerModeEnabledAsync(): Promise<boolean>                // Low Power Mode (iOS) / Power Saver (Android)
 isBatteryOptimizationEnabledAsync(): Promise<boolean>         // Android only
 getPowerStateAsync(): Promise<PowerState>                     // combined level + state + lowPowerMode
-addBatteryLevelListener(listener): Subscription                // fires on battery level change
-addBatteryStateListener(listener): Subscription                // fires on battery state change
-addLowPowerModeListener(listener): Subscription                // fires when low-power mode toggles
+addBatteryLevelListener(listener): EventSubscription           // fires on battery level change
+addBatteryStateListener(listener): EventSubscription           // fires on battery state change
+addLowPowerModeListener(listener): EventSubscription           // fires when low-power mode toggles
 ```
 
 Plus `BatteryState` (enum), `PowerState`, `BatteryLevelEvent`, `BatteryStateEvent`,
-`PowerModeEvent` — ported from upstream's `Battery.types.ts`. Upstream also exposes
-`useBatteryLevel` / `useBatteryState` / `useLowPowerMode` / `usePowerState` React hooks; per this
-repo's core/adapter split, those become adapter-owned lifecycle wrappers (React hooks, Vue
-composables, …) over the same shared core, not core exports themselves.
-
-## Reference
-
-- [`../local-auth`](../local-auth) — nearest already-implemented sibling package: an
-  `expo-modules-core`-based wrapper with the same shape this package will follow (framework-agnostic
-  `core/`, thin per-adapter re-export entries).
-- [`symbiote-expo-native-module`](../../.claude/skills/symbiote-expo-native-module/SKILL.md) — the
-  real wrapping mechanics (depend on `expo-modules-core` only, never the `expo` meta-package; port
-  upstream JS into `core/` rather than importing it; autolinking) that will apply once this moves
-  past skeleton.
+`PowerModeEvent` — ported from upstream's `Battery.types.ts`.
+
+```ts
+import { getBatteryLevelAsync, addBatteryLevelListener } from '@symbiote-native/battery';
+
+// framework-scoped entry points re-export the same free functions, plus a lifecycle
+// hook/composable/service per listener:
+import { useBatteryLevel, useBatteryState, useLowPowerMode } from '@symbiote-native/battery/react';
+import { useBatteryLevel, useBatteryState, useLowPowerMode } from '@symbiote-native/battery/vue';
+import {
+  BatteryLevelService,
+  BatteryStateService,
+  LowPowerModeService,
+} 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`/
+`useLowPowerMode`.
+
+## Test it
+
+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,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
+[README](../../README.md).
+
+The Android/iOS native wiring is done across all four `examples/expo-*` canary apps
+(`examples/expo-react`, `examples/expo-vue-sfc`, `examples/expo-vue-tsx`, `examples/expo-angular`);
+this package isn't yet in the public, non-Expo `examples/react` canary.

package/build/angular/index.d.ts

@@ -0,0 +1,4 @@
+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/build/angular/index.js

@@ -0,0 +1,8 @@
+// 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/index.js';
+export { BatteryStateService } from './services/battery-state.service/index.js';
+export { LowPowerModeService } from './services/low-power-mode.service/index.js';
+export { isAvailableAsync, getBatteryLevelAsync, getBatteryStateAsync, isLowPowerModeEnabledAsync, isBatteryOptimizationEnabledAsync, getPowerStateAsync, addBatteryLevelListener, addBatteryStateListener, addLowPowerModeListener, BatteryState, } from '../core/index.js';

package/build/angular/services/battery-level.service/index.d.ts

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

package/build/angular/services/battery-level.service/index.js

@@ -0,0 +1,74 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { effect, inject, Injectable, Injector, signal } from '@angular/core';
+import { addBatteryLevelListener, getBatteryLevelAsync } from '../../../core/index.js';
+// 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.
+let BatteryLevelService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var BatteryLevelService = 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);
+            BatteryLevelService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        injector = inject(Injector);
+        connect() {
+            const 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();
+        }
+    };
+    return BatteryLevelService = _classThis;
+})();
+export { BatteryLevelService };

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

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

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

@@ -0,0 +1,69 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { effect, inject, Injectable, Injector, signal } from '@angular/core';
+import { addBatteryStateListener, BatteryState, getBatteryStateAsync } from '../../../core/index.js';
+// 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() }}
+let BatteryStateService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var BatteryStateService = 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);
+            BatteryStateService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        injector = inject(Injector);
+        connect() {
+            const batteryState = signal(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();
+        }
+    };
+    return BatteryStateService = _classThis;
+})();
+export { BatteryStateService };

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

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

package/build/angular/services/low-power-mode.service/index.js

@@ -0,0 +1,69 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { effect, inject, Injectable, Injector, signal } from '@angular/core';
+import { addLowPowerModeListener, isLowPowerModeEnabledAsync } from '../../../core/index.js';
+// 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() }}
+let LowPowerModeService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var LowPowerModeService = 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);
+            LowPowerModeService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        injector = inject(Injector);
+        connect() {
+            const 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();
+        }
+    };
+    return LowPowerModeService = _classThis;
+})();
+export { LowPowerModeService };

package/build/core/battery.d.ts

@@ -0,0 +1,44 @@
+import type { EventSubscription } from 'expo-modules-core';
+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 declare function isAvailableAsync(): Promise<boolean>;
+/**
+ * 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 declare function getBatteryLevelAsync(): Promise<number>;
+/** Tells the battery's current state. */
+export declare function getBatteryStateAsync(): Promise<BatteryState>;
+/**
+ * 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 declare function isLowPowerModeEnabledAsync(): Promise<boolean>;
+/**
+ * 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 declare function isBatteryOptimizationEnabledAsync(): Promise<boolean>;
+/**
+ * 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 declare function getPowerStateAsync(): Promise<PowerState>;
+/**
+ * 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 declare function addBatteryLevelListener(listener: (event: BatteryLevelEvent) => void): EventSubscription;
+/** Subscribe to battery state (charging/full/unplugged/unknown) change updates. */
+export declare function addBatteryStateListener(listener: (event: BatteryStateEvent) => void): EventSubscription;
+/**
+ * Subscribe to Power Saver Mode (Android) / Low Power Mode (iOS) updates. Fires whenever the
+ * power mode is toggled.
+ */
+export declare function addLowPowerModeListener(listener: (event: PowerModeEvent) => void): EventSubscription;

package/build/core/battery.js

@@ -0,0 +1,79 @@
+import { expoBattery } from './native-module.js';
+import { BatteryState, } from './types.js';
+/**
+ * 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() {
+    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() {
+    if (!expoBattery.getBatteryLevelAsync) {
+        return -1;
+    }
+    return expoBattery.getBatteryLevelAsync();
+}
+/** Tells the battery's current state. */
+export async function getBatteryStateAsync() {
+    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() {
+    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() {
+    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() {
+    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) {
+    return expoBattery.addListener('Expo.batteryLevelDidChange', listener);
+}
+/** Subscribe to battery state (charging/full/unplugged/unknown) change updates. */
+export function addBatteryStateListener(listener) {
+    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) {
+    return expoBattery.addListener('Expo.powerModeDidChange', listener);
+}

package/build/core/index.d.ts

@@ -0,0 +1,3 @@
+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/build/core/index.js

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

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

@@ -0,0 +1,13 @@
+import type { EventSubscription } from 'expo-modules-core';
+import type { BatteryLevelEvent, BatteryState, BatteryStateEvent, PowerModeEvent } from './types';
+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 declare const expoBattery: INativeBatteryModule;

package/build/core/native-module.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_BATTERY_MODULE_NAME = 'ExpoBattery';
+export const expoBattery = requireNativeModule(EXPO_BATTERY_MODULE_NAME);