@symbiote-native/battery 0.0.1 → 0.2.0

package/build/core/types.d.ts

@@ -0,0 +1,40 @@
+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 declare 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 = 1,
+    /** If battery is charging. */
+    CHARGING = 2,
+    /** If the battery level is full. */
+    FULL = 3,
+    /**
+     * 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 = 4
+}
+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/build/core/types.js

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

package/build/react/hooks/use-battery-level/index.d.ts

@@ -0,0 +1 @@
+export declare function useBatteryLevel(): number;

package/build/react/hooks/use-battery-level/index.js

@@ -0,0 +1,16 @@
+// 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/index.js';
+export function useBatteryLevel() {
+    const [batteryLevel, setBatteryLevel] = useState(-1);
+    useEffect(() => {
+        getBatteryLevelAsync().then(setBatteryLevel);
+        const subscription = addBatteryLevelListener(event => setBatteryLevel(event.batteryLevel));
+        return () => subscription.remove();
+    }, []);
+    return batteryLevel;
+}

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

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

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

@@ -0,0 +1,14 @@
+// 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/index.js';
+export function useBatteryState() {
+    const [batteryState, setBatteryState] = useState(BatteryState.UNKNOWN);
+    useEffect(() => {
+        getBatteryStateAsync().then(setBatteryState);
+        const subscription = addBatteryStateListener(event => setBatteryState(event.batteryState));
+        return () => subscription.remove();
+    }, []);
+    return batteryState;
+}

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

@@ -0,0 +1 @@
+export declare function useLowPowerMode(): boolean;

package/build/react/hooks/use-low-power-mode/index.js

@@ -0,0 +1,15 @@
+// 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/index.js';
+export function useLowPowerMode() {
+    const [lowPowerMode, setLowPowerMode] = useState(false);
+    useEffect(() => {
+        isLowPowerModeEnabledAsync().then(setLowPowerMode);
+        const subscription = addLowPowerModeListener(event => setLowPowerMode(event.lowPowerMode));
+        return () => subscription.remove();
+    }, []);
+    return lowPowerMode;
+}

package/build/react/index.d.ts

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

package/build/react/index.js

@@ -0,0 +1,9 @@
+// @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/index.js';
+export { useBatteryState } from './hooks/use-battery-state/index.js';
+export { useLowPowerMode } from './hooks/use-low-power-mode/index.js';
+export * from '../core/index.js';

package/build/svelte/index.d.ts

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

package/build/svelte/index.js

@@ -0,0 +1,9 @@
+// @symbiote-native/battery/svelte: the Svelte entry over the framework-agnostic core. Battery's
+// three subscription-backed values (level/state/low-power-mode) each get their own lifecycle
+// rune, matching upstream's own useBatteryLevel/useBatteryState/useLowPowerMode being three
+// separate hooks, not one combined hook — mirrors the lifecycle-bucket naming convention of
+// adapters/svelte/src/runes (never `hooks/`/`composables/`, those are React's and Vue's terms).
+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 * from '../core/index.js';

package/build/svelte/runes/use-battery-level.svelte.d.ts

@@ -0,0 +1,3 @@
+export declare function useBatteryLevel(): {
+    readonly current: number;
+};

package/build/svelte/runes/use-battery-level.svelte.js

@@ -0,0 +1,37 @@
+// Svelte lifecycle wiring over the framework-agnostic core (core/battery.ts) — the Svelte twin of
+// vue/composables/use-battery-level and react/hooks/use-battery-level. Seeds the initial value
+// with a one-shot getBatteryLevelAsync() call before the first native event fires, matching
+// upstream's own useBatteryLevel.
+//
+// `.svelte.ts` (not `.ts`): runes ($state/$effect) are only usable in a file with this extension
+// outside an actual `.svelte` component. `runes/` is Svelte's own term for the bucket React calls
+// `hooks/` and Vue calls `composables/` — see adapters/svelte/src/runes.
+//
+// Vue's onMounted/onUnmounted pair collapses into ONE `$effect` whose returned function is the
+// teardown. The effect only WRITES `batteryLevel`, never reads it, so its dependency set stays
+// empty: it runs exactly once on mount and cleans up exactly once on unmount.
+//
+// Returns a boxed getter object, NOT a bare `$state`: Svelte 5 reactivity is lexically scoped to
+// the declaring module, so a raw `let x = $state(...)` handed out of a plain function arrives
+// dead at the caller. `{ get current() { … } }` is the sanctioned way across, read as `.current`
+// exactly like Vue's `Ref` is unwrapped via `.value`.
+import { addBatteryLevelListener, getBatteryLevelAsync } from '../../core/index.js';
+// core/battery.ts's documented sentinel for "this device cannot report a battery level".
+const UNKNOWN_BATTERY_LEVEL = -1;
+export function useBatteryLevel() {
+    let batteryLevel = $state(UNKNOWN_BATTERY_LEVEL);
+    $effect(() => {
+        getBatteryLevelAsync().then(level => {
+            batteryLevel = level;
+        });
+        const subscription = addBatteryLevelListener(event => {
+            batteryLevel = event.batteryLevel;
+        });
+        return () => subscription.remove();
+    });
+    return {
+        get current() {
+            return batteryLevel;
+        },
+    };
+}

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

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

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

@@ -0,0 +1,22 @@
+// Svelte lifecycle wiring over the framework-agnostic core (core/battery.ts) — mirrors
+// use-battery-level.svelte.ts's shape; see its header for the `.svelte.ts`/`runes/`/boxed-getter
+// reasoning. Seeds the initial value with a one-shot getBatteryStateAsync() call before the first
+// native event fires, matching upstream's own useBatteryState.
+import { addBatteryStateListener, BatteryState, getBatteryStateAsync, } from '../../core/index.js';
+export function useBatteryState() {
+    let batteryState = $state(BatteryState.UNKNOWN);
+    $effect(() => {
+        getBatteryStateAsync().then(state => {
+            batteryState = state;
+        });
+        const subscription = addBatteryStateListener(event => {
+            batteryState = event.batteryState;
+        });
+        return () => subscription.remove();
+    });
+    return {
+        get current() {
+            return batteryState;
+        },
+    };
+}

package/build/svelte/runes/use-low-power-mode.svelte.d.ts

@@ -0,0 +1,3 @@
+export declare function useLowPowerMode(): {
+    readonly current: boolean;
+};

package/build/svelte/runes/use-low-power-mode.svelte.js

@@ -0,0 +1,22 @@
+// Svelte lifecycle wiring over the framework-agnostic core (core/battery.ts) — mirrors
+// use-battery-level.svelte.ts's shape; see its header for the `.svelte.ts`/`runes/`/boxed-getter
+// reasoning. Seeds the initial value with a one-shot isLowPowerModeEnabledAsync() call before the
+// first native event fires, matching upstream's own useLowPowerMode.
+import { addLowPowerModeListener, isLowPowerModeEnabledAsync, } from '../../core/index.js';
+export function useLowPowerMode() {
+    let lowPowerMode = $state(false);
+    $effect(() => {
+        isLowPowerModeEnabledAsync().then(enabled => {
+            lowPowerMode = enabled;
+        });
+        const subscription = addLowPowerModeListener(event => {
+            lowPowerMode = event.lowPowerMode;
+        });
+        return () => subscription.remove();
+    });
+    return {
+        get current() {
+            return lowPowerMode;
+        },
+    };
+}

package/build/vue/composables/use-battery-level/index.d.ts

@@ -0,0 +1,2 @@
+import { type Ref } from '@vue/runtime-core';
+export declare function useBatteryLevel(): Ref<number>;

package/build/vue/composables/use-battery-level/index.js

@@ -0,0 +1,23 @@
+// 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 } from '@vue/runtime-core';
+import { addBatteryLevelListener, getBatteryLevelAsync, } from '../../../core/index.js';
+export function useBatteryLevel() {
+    const batteryLevel = ref(-1);
+    let subscription;
+    onMounted(() => {
+        getBatteryLevelAsync().then(level => {
+            batteryLevel.value = level;
+        });
+        subscription = addBatteryLevelListener(event => {
+            batteryLevel.value = event.batteryLevel;
+        });
+    });
+    onUnmounted(() => {
+        subscription?.remove();
+    });
+    return batteryLevel;
+}

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

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

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

@@ -0,0 +1,21 @@
+// 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 } from '@vue/runtime-core';
+import { addBatteryStateListener, BatteryState, getBatteryStateAsync, } from '../../../core/index.js';
+export function useBatteryState() {
+    const batteryState = ref(BatteryState.UNKNOWN);
+    let subscription;
+    onMounted(() => {
+        getBatteryStateAsync().then(state => {
+            batteryState.value = state;
+        });
+        subscription = addBatteryStateListener(event => {
+            batteryState.value = event.batteryState;
+        });
+    });
+    onUnmounted(() => {
+        subscription?.remove();
+    });
+    return batteryState;
+}

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

@@ -0,0 +1,2 @@
+import { type Ref } from '@vue/runtime-core';
+export declare function useLowPowerMode(): Ref<boolean>;

package/build/vue/composables/use-low-power-mode/index.js

@@ -0,0 +1,22 @@
+// 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 } from '@vue/runtime-core';
+import { addLowPowerModeListener, isLowPowerModeEnabledAsync, } from '../../../core/index.js';
+export function useLowPowerMode() {
+    const lowPowerMode = ref(false);
+    let subscription;
+    onMounted(() => {
+        isLowPowerModeEnabledAsync().then(enabled => {
+            lowPowerMode.value = enabled;
+        });
+        subscription = addLowPowerModeListener(event => {
+            lowPowerMode.value = event.lowPowerMode;
+        });
+    });
+    onUnmounted(() => {
+        subscription?.remove();
+    });
+    return lowPowerMode;
+}

package/build/vue/index.d.ts

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

package/build/vue/index.js

@@ -0,0 +1,9 @@
+// @symbiote-native/battery/vue: the Vue entry over the framework-agnostic core. Battery's three
+// subscription-backed values (level/state/low-power-mode) each get their own lifecycle
+// composable, matching upstream's own useBatteryLevel/useBatteryState/useLowPowerMode being
+// three separate hooks, not one combined hook — mirrors the lifecycle-bucket naming convention
+// of adapters/vue/src/composables (never `hooks/`, that's React's term).
+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 * from '../core/index.js';

package/build-ngc/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 * from '../core';

package/build-ngc/angular/index.js

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

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

@@ -0,0 +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"}

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

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

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

@@ -0,0 +1,33 @@
+import { effect, inject, Injectable, Injector, signal } from '@angular/core';
+import { addBatteryLevelListener, getBatteryLevelAsync } from '../../../core';
+import * as i0 from "@angular/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.
+export class BatteryLevelService {
+    injector = inject(Injector);
+    connect() {
+        const batteryLevel = signal(-1, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "batteryLevel" }] : /* istanbul ignore next */ []));
+        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();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: BatteryLevelService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: BatteryLevelService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: BatteryLevelService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/angular/services/battery-level.service/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAe,MAAM,eAAe,CAAC;AAC1F,OAAO,EAAE,uBAAuB,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;;AAE9E,yFAAyF;AACzF,4FAA4F;AAC5F,+FAA+F;AAC/F,gCAAgC;AAChC,EAAE;AACF,mEAAmE;AACnE,sCAAsC;AACtC,EAAE;AACF,+FAA+F;AAC/F,+DAA+D;AAE/D,MAAM,OAAO,mBAAmB;IACb,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;IAE7C,OAAO;QACL,MAAM,YAAY,GAAG,MAAM,CAAC,CAAC,CAAC;yFAAC,CAAC;QAEhC,MAAM,CACJ,SAAS,CAAC,EAAE;YACV,oBAAoB,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;YAC9D,MAAM,YAAY,GAAG,uBAAuB,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC;YAC5F,SAAS,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC;QACzC,CAAC,EACD,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAC5B,CAAC;QAEF,OAAO,YAAY,CAAC,UAAU,EAAE,CAAC;IACnC,CAAC;uGAhBU,mBAAmB;2GAAnB,mBAAmB,cADN,MAAM;;2FACnB,mBAAmB;kBAD/B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE"}

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

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

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

@@ -0,0 +1,28 @@
+import { effect, inject, Injectable, Injector, signal } from '@angular/core';
+import { addBatteryStateListener, BatteryState, getBatteryStateAsync } from '../../../core';
+import * as i0 from "@angular/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() }}
+export class BatteryStateService {
+    injector = inject(Injector);
+    connect() {
+        const batteryState = signal(BatteryState.UNKNOWN, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "batteryState" }] : /* istanbul ignore next */ []));
+        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();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: BatteryStateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: BatteryStateService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: BatteryStateService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/angular/services/battery-state.service/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAe,MAAM,eAAe,CAAC;AAC1F,OAAO,EAAE,uBAAuB,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;;AAE5F,6FAA6F;AAC7F,6DAA6D;AAC7D,EAAE;AACF,mEAAmE;AACnE,sCAAsC;AAEtC,MAAM,OAAO,mBAAmB;IACb,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;IAE7C,OAAO;QACL,MAAM,YAAY,GAAG,MAAM,CAAe,YAAY,CAAC,OAAO;yFAAC,CAAC;QAEhE,MAAM,CACJ,SAAS,CAAC,EAAE;YACV,oBAAoB,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;YAC9D,MAAM,YAAY,GAAG,uBAAuB,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC;YAC5F,SAAS,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC;QACzC,CAAC,EACD,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAC5B,CAAC;QAEF,OAAO,YAAY,CAAC,UAAU,EAAE,CAAC;IACnC,CAAC;uGAhBU,mBAAmB;2GAAnB,mBAAmB,cADN,MAAM;;2FACnB,mBAAmB;kBAD/B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE"}

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

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

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

@@ -0,0 +1,28 @@
+import { effect, inject, Injectable, Injector, signal } from '@angular/core';
+import { addLowPowerModeListener, isLowPowerModeEnabledAsync } from '../../../core';
+import * as i0 from "@angular/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() }}
+export class LowPowerModeService {
+    injector = inject(Injector);
+    connect() {
+        const lowPowerMode = signal(false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "lowPowerMode" }] : /* istanbul ignore next */ []));
+        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();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: LowPowerModeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: LowPowerModeService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: LowPowerModeService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/angular/services/low-power-mode.service/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAe,MAAM,eAAe,CAAC;AAC1F,OAAO,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,MAAM,eAAe,CAAC;;AAEpF,6FAA6F;AAC7F,6DAA6D;AAC7D,EAAE;AACF,mEAAmE;AACnE,sCAAsC;AAEtC,MAAM,OAAO,mBAAmB;IACb,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;IAE7C,OAAO;QACL,MAAM,YAAY,GAAG,MAAM,CAAC,KAAK;yFAAC,CAAC;QAEnC,MAAM,CACJ,SAAS,CAAC,EAAE;YACV,0BAA0B,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,YAAY,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC;YACxE,MAAM,YAAY,GAAG,uBAAuB,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC;YAC5F,SAAS,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC,CAAC;QACzC,CAAC,EACD,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAC5B,CAAC;QAEF,OAAO,YAAY,CAAC,UAAU,EAAE,CAAC;IACnC,CAAC;uGAhBU,mBAAmB;2GAAnB,mBAAmB,cADN,MAAM;;2FACnB,mBAAmB;kBAD/B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE"}

package/build-ngc/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;