@symbiote-native/battery 0.0.1 → 0.2.0

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

package/src/svelte/index.ts

@@ -0,0 +1,10 @@
+// @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';

package/src/svelte/runes/use-battery-level.svelte.ts

@@ -0,0 +1,41 @@
+// 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, type EventSubscription } from '../../core';
+
+// core/battery.ts's documented sentinel for "this device cannot report a battery level".
+const UNKNOWN_BATTERY_LEVEL = -1;
+
+export function useBatteryLevel(): { readonly current: number } {
+  let batteryLevel = $state(UNKNOWN_BATTERY_LEVEL);
+
+  $effect(() => {
+    getBatteryLevelAsync().then(level => {
+      batteryLevel = level;
+    });
+    const subscription: EventSubscription = addBatteryLevelListener(event => {
+      batteryLevel = event.batteryLevel;
+    });
+    return () => subscription.remove();
+  });
+
+  return {
+    get current(): number {
+      return batteryLevel;
+    },
+  };
+}

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

@@ -0,0 +1,30 @@
+// 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,
+  type EventSubscription,
+} from '../../core';
+
+export function useBatteryState(): { readonly current: BatteryState } {
+  let batteryState = $state<BatteryState>(BatteryState.UNKNOWN);
+
+  $effect(() => {
+    getBatteryStateAsync().then(state => {
+      batteryState = state;
+    });
+    const subscription: EventSubscription = addBatteryStateListener(event => {
+      batteryState = event.batteryState;
+    });
+    return () => subscription.remove();
+  });
+
+  return {
+    get current(): BatteryState {
+      return batteryState;
+    },
+  };
+}

package/src/svelte/runes/use-low-power-mode.svelte.ts

@@ -0,0 +1,29 @@
+// 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,
+  type EventSubscription,
+} from '../../core';
+
+export function useLowPowerMode(): { readonly current: boolean } {
+  let lowPowerMode = $state(false);
+
+  $effect(() => {
+    isLowPowerModeEnabledAsync().then(enabled => {
+      lowPowerMode = enabled;
+    });
+    const subscription: EventSubscription = addLowPowerModeListener(event => {
+      lowPowerMode = event.lowPowerMode;
+    });
+    return () => subscription.remove();
+  });
+
+  return {
+    get current(): boolean {
+      return lowPowerMode;
+    },
+  };
+}

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

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

package/src/vue/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;
+}

package/src/vue/index.ts

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