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

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

"use strict";

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 index_native_exports = {};
__export(index_native_exports, {
	Battery: () => Battery,
	useBatteryLevel: () => useBatteryLevel,
	useBatteryState: () => useBatteryState,
	useLowPowerMode: () => useLowPowerMode,
	usePowerState: () => usePowerState
});
module.exports = __toCommonJS(index_native_exports);
var import_react = require("react");
var import_react_native_nitro_modules = require("react-native-nitro-modules");
var import_nativeError = require("../nativeError.native.js");
var import_validate = require("./validate.native.js");
var hybrid;
function native() {
	hybrid !== null && hybrid !== void 0 ? hybrid : hybrid = import_react_native_nitro_modules.NitroModules.createHybridObject("OneBattery");
	return hybrid;
}
function getLevel() {
	return native().getLevel().catch(import_nativeError.rethrowNativeError);
}
function getState() {
	return native().getState().catch(import_nativeError.rethrowNativeError);
}
function getPowerState() {
	return native().getPowerState().catch(import_nativeError.rethrowNativeError);
}
function isLowPowerModeEnabled() {
	return native().isLowPowerModeEnabled().catch(import_nativeError.rethrowNativeError);
}
function isAvailable() {
	return native().isAvailable();
}
function addLevelListener(listener) {
	(0, import_validate.assertLevelListener)(listener);
	var remove = native().addLevelListener(listener);
	return { remove: function remove1() {
		return remove();
	} };
}
function addStateListener(listener) {
	(0, import_validate.assertStateListener)(listener);
	var remove = native().addStateListener(listener);
	return { remove: function remove1() {
		return remove();
	} };
}
function addLowPowerModeListener(listener) {
	(0, import_validate.assertLowPowerModeListener)(listener);
	var remove = native().addLowPowerModeListener(listener);
	return { remove: function remove1() {
		return remove();
	} };
}
function useBatteryLevel() {
	var [level, setLevel] = (0, import_react.useState)(-1);
	(0, import_react.useEffect)(function() {
		var active = true;
		var fromEvent = false;
		getLevel().then(function(next) {
			if (active && !fromEvent) setLevel(next);
		}).catch(function() {});
		var subscription = addLevelListener(function(event) {
			if (active) {
				fromEvent = true;
				setLevel(event.batteryLevel);
			}
		});
		return function() {
			active = false;
			subscription.remove();
		};
	}, []);
	return level;
}
function useBatteryState() {
	var [state, setState] = (0, import_react.useState)("unknown");
	(0, import_react.useEffect)(function() {
		var active = true;
		var fromEvent = false;
		getState().then(function(next) {
			if (active && !fromEvent) setState(next);
		}).catch(function() {});
		var subscription = addStateListener(function(event) {
			if (active) {
				fromEvent = true;
				setState(event.batteryState);
			}
		});
		return function() {
			active = false;
			subscription.remove();
		};
	}, []);
	return state;
}
function useLowPowerMode() {
	var [enabled, setEnabled] = (0, import_react.useState)(false);
	(0, import_react.useEffect)(function() {
		var active = true;
		var fromEvent = false;
		isLowPowerModeEnabled().then(function(next) {
			if (active && !fromEvent) setEnabled(next);
		}).catch(function() {});
		var subscription = addLowPowerModeListener(function(event) {
			if (active) {
				fromEvent = true;
				setEnabled(event.lowPowerMode);
			}
		});
		return function() {
			active = false;
			subscription.remove();
		};
	}, []);
	return enabled;
}
function usePowerState() {
	var [power, setPower] = (0, import_react.useState)({
		batteryLevel: -1,
		batteryState: "unknown",
		lowPowerMode: false
	});
	(0, import_react.useEffect)(function() {
		var active = true;
		var levelFromEvent = false;
		var stateFromEvent = false;
		var modeFromEvent = false;
		getPowerState().then(function(next) {
			if (!active) return;
			setPower(function(current) {
				return {
					batteryLevel: levelFromEvent ? current.batteryLevel : next.batteryLevel,
					batteryState: stateFromEvent ? current.batteryState : next.batteryState,
					lowPowerMode: modeFromEvent ? current.lowPowerMode : next.lowPowerMode
				};
			});
		}).catch(function() {});
		var onLevel = addLevelListener(function(event) {
			if (active) {
				levelFromEvent = true;
				setPower(function(current) {
					return {
						...current,
						batteryLevel: event.batteryLevel
					};
				});
			}
		});
		var onState = addStateListener(function(event) {
			if (active) {
				stateFromEvent = true;
				setPower(function(current) {
					return {
						...current,
						batteryState: event.batteryState
					};
				});
			}
		});
		var onMode = addLowPowerModeListener(function(event) {
			if (active) {
				modeFromEvent = true;
				setPower(function(current) {
					return {
						...current,
						lowPowerMode: event.lowPowerMode
					};
				});
			}
		});
		return function() {
			active = false;
			onLevel.remove();
			onState.remove();
			onMode.remove();
		};
	}, []);
	return power;
}
var Battery = Object.freeze({
	getLevel,
	getState,
	getPowerState,
	isLowPowerModeEnabled,
	isAvailable,
	addLevelListener,
	addStateListener,
	addLowPowerModeListener
});

//# sourceMappingURL=index.native.js.map