one/dist/cjs/platform/battery/index.cjs

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

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
	for (var name in all) __defProp(target, name, {
		get: all[name],
		enumerable: true
	});
};
var __copyProps = (to, from, except, desc) => {
	if (from && typeof from === "object" || typeof from === "function") {
		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
			get: () => from[key],
			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
		});
	}
	return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var battery_exports = {};
__export(battery_exports, {
	Battery: () => Battery,
	useBatteryLevel: () => useBatteryLevel,
	useBatteryState: () => useBatteryState,
	useLowPowerMode: () => useLowPowerMode,
	usePowerState: () => usePowerState
});
module.exports = __toCommonJS(battery_exports);
var import_react = require("react");
var import_validate = require("./validate.cjs");
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) {
	(0, import_validate.assertLevelListener)(listener);
	return listen("levelchange", () => {
		void getLevel().then((batteryLevel) => listener({ batteryLevel }));
	});
}
function addStateListener(listener) {
	(0, import_validate.assertStateListener)(listener);
	return listen("chargingchange", () => {
		void getState().then((batteryState) => listener({ batteryState }));
	});
}
function addLowPowerModeListener(listener) {
	(0, import_validate.assertLowPowerModeListener)(listener);
	return { remove: () => {} };
}
function useBatteryLevel() {
	const [level, setLevel] = (0, import_react.useState)(1);
	(0, import_react.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] = (0, import_react.useState)("unknown");
	(0, import_react.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] = (0, import_react.useState)(false);
	return enabled;
}
function usePowerState() {
	const [power, setPower] = (0, import_react.useState)({
		batteryLevel: 1,
		batteryState: "unknown",
		lowPowerMode: false
	});
	(0, import_react.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
});