one/dist/esm/platform/battery/index.mjs

One is a React framework for web, iOS, and Android apps.

import { useEffect, useState } from "react";
import { assertLevelListener, assertLowPowerModeListener, assertStateListener } from "./validate.mjs";

function getBatteryFn() {
	if (typeof navigator === "undefined") return void 0;
	const getBattery = navigator.getBattery;
	return typeof getBattery === "function" ? getBattery : void 0;
}
async function systemBattery() {
	const getBattery = getBatteryFn();
	if (!getBattery) return void 0;
	try {
		return await getBattery();
	} catch {
		return void 0;
	}
}
async function getLevel() {
	const battery = await systemBattery();
	return battery ? battery.level : 1;
}
function stateOf(battery) {
	if (!battery) return "unknown";
	return battery.charging ? "charging" : "unplugged";
}
async function getState() {
	return stateOf(await systemBattery());
}
async function getPowerState() {
	const battery = await systemBattery();
	return {
		batteryLevel: battery ? battery.level : 1,
		batteryState: stateOf(battery),
		lowPowerMode: false
	};
}
async function isLowPowerModeEnabled() {
	return false;
}
function isAvailable() {
	return getBatteryFn() !== void 0;
}
function listen(event, listener) {
	if (typeof window === "undefined") return { remove: () => {} };
	let removed = false;
	void systemBattery().then((battery) => {
		if (removed) return;
		battery?.addEventListener(event, listener);
	});
	return { remove: () => {
		removed = true;
		void systemBattery().then((battery) => {
			battery?.removeEventListener(event, listener);
		});
	} };
}
function addLevelListener(listener) {
	assertLevelListener(listener);
	return listen("levelchange", () => {
		void getLevel().then((batteryLevel) => listener({ batteryLevel }));
	});
}
function addStateListener(listener) {
	assertStateListener(listener);
	return listen("chargingchange", () => {
		void getState().then((batteryState) => listener({ batteryState }));
	});
}
function addLowPowerModeListener(listener) {
	assertLowPowerModeListener(listener);
	return { remove: () => {} };
}
function useBatteryLevel() {
	const [level, setLevel] = useState(1);
	useEffect(() => {
		let active = true;
		let fromEvent = false;
		void getLevel().then((next) => {
			if (active && !fromEvent) setLevel(next);
		});
		const subscription = addLevelListener((event) => {
			if (active) {
				fromEvent = true;
				setLevel(event.batteryLevel);
			}
		});
		return () => {
			active = false;
			subscription.remove();
		};
	}, []);
	return level;
}
function useBatteryState() {
	const [state, setState] = useState("unknown");
	useEffect(() => {
		let active = true;
		let fromEvent = false;
		void getState().then((next) => {
			if (active && !fromEvent) setState(next);
		});
		const subscription = addStateListener((event) => {
			if (active) {
				fromEvent = true;
				setState(event.batteryState);
			}
		});
		return () => {
			active = false;
			subscription.remove();
		};
	}, []);
	return state;
}
function useLowPowerMode() {
	const [enabled] = useState(false);
	return enabled;
}
function usePowerState() {
	const [power, setPower] = useState({
		batteryLevel: 1,
		batteryState: "unknown",
		lowPowerMode: false
	});
	useEffect(() => {
		let active = true;
		let levelFromEvent = false;
		let stateFromEvent = false;
		void getPowerState().then((next) => {
			if (!active) return;
			setPower((current) => ({
				batteryLevel: levelFromEvent ? current.batteryLevel : next.batteryLevel,
				batteryState: stateFromEvent ? current.batteryState : next.batteryState,
				lowPowerMode: next.lowPowerMode
			}));
		});
		const onLevel = addLevelListener((event) => {
			if (active) {
				levelFromEvent = true;
				setPower((current) => ({
					...current,
					batteryLevel: event.batteryLevel
				}));
			}
		});
		const onState = addStateListener((event) => {
			if (active) {
				stateFromEvent = true;
				setPower((current) => ({
					...current,
					batteryState: event.batteryState
				}));
			}
		});
		return () => {
			active = false;
			onLevel.remove();
			onState.remove();
		};
	}, []);
	return power;
}
const Battery = Object.freeze({
	getLevel,
	getState,
	getPowerState,
	isLowPowerModeEnabled,
	isAvailable,
	addLevelListener,
	addStateListener,
	addLowPowerModeListener
});

export { Battery, useBatteryLevel, useBatteryState, useLowPowerMode, usePowerState };
//# sourceMappingURL=index.mjs.map