one/dist/cjs/platform/adaptive/index.native.cjs

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

"use strict";

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
	value: mod,
	enumerable: true
}) : target, mod));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var index_native_exports = {};
__export(index_native_exports, {
	ReservedRegions: () => ReservedRegions,
	getHinge: () => getHinge,
	getSizeClass: () => getSizeClass,
	onHingeChange: () => onHingeChange,
	useHinge: () => useHinge,
	useReservedRegions: () => import_reservedRegionsContext.useRegions,
	useReservedRegionsReady: () => import_reservedRegionsContext.useReady,
	useSizeClass: () => useSizeClass,
	useSpanning: () => import_reservedRegionsContext.useSpanning,
	useWindowSegments: () => import_reservedRegionsContext.useSegments
});
module.exports = __toCommonJS(index_native_exports);
var import_react = require("react");
var import_react_native_nitro_modules = require("react-native-nitro-modules");
var ReservedRegions = __toESM(require("./ReservedRegions.native.js"), 1);
var import_reservedRegionsContext = require("./reservedRegionsContext.native.js");
var hybrid;
function native() {
	if (hybrid === void 0) {
		hybrid = import_react_native_nitro_modules.NitroModules.createHybridObject("OneAdaptive");
	}
	return hybrid;
}
var DEFAULT_SIZE_CLASS = {
	horizontal: "unspecified",
	vertical: "unspecified"
};
var currentSizeClass = DEFAULT_SIZE_CLASS;
var currentHinge = null;
function seedFromNative() {
	var _created_getInitialHinge;
	var created = native();
	currentSizeClass = created.getInitialSizeClass();
	currentHinge = (_created_getInitialHinge = created.getInitialHinge()) !== null && _created_getInitialHinge !== void 0 ? _created_getInitialHinge : null;
}
seedFromNative();
var sizeClassListeners = /* @__PURE__ */ new Set();
var hingeListeners = /* @__PURE__ */ new Set();
var sizeClassRemove;
var hingeRemove;
var sizeClassGeneration = 0;
var hingeGeneration = 0;
var hingeSeedStale = false;
var sizeClassSeedStale = false;
function sizesEqual(a, b) {
	return a.horizontal === b.horizontal && a.vertical === b.vertical;
}
function hingesEqual(a, b) {
	return a === b || a != null && b != null && a.status === b.status && a.angle === b.angle;
}
function setSizeClass(next) {
	if (sizesEqual(currentSizeClass, next)) return;
	currentSizeClass = next;
	sizeClassListeners.forEach(function(listener) {
		return listener();
	});
}
function setHinge(next) {
	if (hingesEqual(currentHinge, next)) return;
	currentHinge = next;
	hingeListeners.forEach(function(listener) {
		return listener();
	});
}
function subscribeSizeClass(onStoreChange) {
	sizeClassListeners.add(onStoreChange);
	if (sizeClassRemove === void 0) {
		var created = native();
		var generation = ++sizeClassGeneration;
		var sawEvent = false;
		sizeClassRemove = created.addSizeClassListener(function(sizeClass) {
			sawEvent = true;
			setSizeClass(sizeClass);
		});
		created.getSizeClass().then(function(sizeClass) {
			if (generation === sizeClassGeneration && !sawEvent) setSizeClass(sizeClass);
		});
	}
	return function() {
		sizeClassListeners.delete(onStoreChange);
		if (sizeClassListeners.size === 0) {
			sizeClassGeneration++;
			sizeClassRemove === null || sizeClassRemove === void 0 ? void 0 : sizeClassRemove();
			sizeClassRemove = void 0;
			sizeClassSeedStale = true;
		}
	};
}
function subscribeHinge(onStoreChange) {
	hingeListeners.add(onStoreChange);
	if (hingeRemove === void 0) {
		var created = native();
		var generation = ++hingeGeneration;
		var sawEvent = false;
		hingeRemove = created.addHingeListener(function(hinge) {
			sawEvent = true;
			setHinge(hinge !== null && hinge !== void 0 ? hinge : null);
		});
		created.getHinge().then(function(hinge) {
			if (generation === hingeGeneration && !sawEvent) setHinge(hinge !== null && hinge !== void 0 ? hinge : null);
		});
	}
	return function() {
		hingeListeners.delete(onStoreChange);
		if (hingeListeners.size === 0) {
			hingeGeneration++;
			hingeRemove === null || hingeRemove === void 0 ? void 0 : hingeRemove();
			hingeRemove = void 0;
			hingeSeedStale = true;
		}
	};
}
function sizeClassSnapshot() {
	if (sizeClassSeedStale) {
		sizeClassSeedStale = false;
		currentSizeClass = native().getInitialSizeClass();
	}
	return currentSizeClass;
}
function hingeSnapshot() {
	if (hingeSeedStale) {
		var _native_getInitialHinge;
		hingeSeedStale = false;
		currentHinge = (_native_getInitialHinge = native().getInitialHinge()) !== null && _native_getInitialHinge !== void 0 ? _native_getInitialHinge : null;
	}
	return currentHinge;
}
function useSizeClass() {
	return (0, import_react.useSyncExternalStore)(subscribeSizeClass, sizeClassSnapshot, function() {
		return DEFAULT_SIZE_CLASS;
	});
}
function getSizeClass() {
	return native().getSizeClass();
}
function useHinge() {
	return (0, import_react.useSyncExternalStore)(subscribeHinge, hingeSnapshot, function() {
		return null;
	});
}
async function getHinge() {
	var _ref;
	return (_ref = await native().getHinge()) !== null && _ref !== void 0 ? _ref : null;
}
function onHingeChange(callback) {
	var remove = native().addHingeListener(function(hinge) {
		return callback(hinge !== null && hinge !== void 0 ? hinge : null);
	});
	return function() {
		return remove();
	};
}