one/dist/cjs/layouts/Stack.native.js

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 Stack_exports = {};
__export(Stack_exports, {
	Stack: () => Stack,
	default: () => Stack_default
});
module.exports = __toCommonJS(Stack_exports);
var import_jsx_runtime = require("react/jsx-runtime");
var import_react = __toESM(require("react"), 1);
var import_children = require("../utils/children.native.js");
var import_Protected = require("../views/Protected.native.js");
var import_Screen = require("../views/Screen.native.js");
var import_stack_navigator = require("./stack-navigator.native.js");
var import_stack_utils = require("./stack-utils/index.native.js");
var import_withLayoutContext = require("./withLayoutContext.native.js");
var NativeStackNavigator = (0, import_stack_navigator.createStackNavigator)().Navigator;
var RNStack = (0, import_withLayoutContext.withLayoutContext)(NativeStackNavigator, void 0, { undeclaredRoutes: true });
function mapChildren(children) {
	return import_react.Children.toArray(children).map(function(child, index) {
		if ((0, import_children.isChildOfType)(child, import_stack_utils.StackScreen)) {
			var _child_props_name;
			var options = (0, import_stack_utils.appendScreenStackPropsToOptions)({}, child.props);
			var { children: _, ...rest } = child.props;
			return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_Screen.Screen, {
				...rest,
				options
			}, (_child_props_name = child.props.name) !== null && _child_props_name !== void 0 ? _child_props_name : index);
		}
		if ((0, import_children.isChildOfType)(child, import_Protected.Protected)) {
			return /* @__PURE__ */ import_react.default.cloneElement(child, { key: `protected-${index}` }, mapChildren(child.props.children));
		}
		if ((0, import_children.isChildOfType)(child, import_stack_utils.StackHeaderComponent)) {
			return null;
		}
		if ((0, import_children.isChildOfType)(child, import_stack_utils.StackToolbarComponent)) {
			return null;
		}
		if ((0, import_children.isChildOfType)(child, import_Screen.Screen)) {
			return child;
		}
		return null;
	}).filter(Boolean);
}
var StackWithComposition = /* @__PURE__ */ import_react.default.forwardRef(function(props, ref) {
	var { children, screenOptions, ...rest } = props;
	var screenOptionsWithHeader = (0, import_react.useMemo)(function() {
		var stackHeader = import_react.Children.toArray(children).find(function(child) {
			return (0, import_children.isChildOfType)(child, import_stack_utils.StackHeaderComponent);
		});
		var stackToolbars = import_react.Children.toArray(children).filter(function(child) {
			return (0, import_children.isChildOfType)(child, import_stack_utils.StackToolbarComponent);
		});
		if (!stackHeader && !stackToolbars.length) return screenOptions;
		var applyComposition = function applyComposition2(opts) {
			var result = opts;
			var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = void 0;
			try {
				for (var _iterator = stackToolbars[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
					var stackToolbar = _step.value;
					result = (0, import_stack_utils.appendStackToolbarPropsToOptions)(result, stackToolbar.props);
				}
			} catch (err) {
				_didIteratorError = true;
				_iteratorError = err;
			} finally {
				try {
					if (!_iteratorNormalCompletion && _iterator.return != null) {
						_iterator.return();
					}
				} finally {
					if (_didIteratorError) {
						throw _iteratorError;
					}
				}
			}
			if (stackHeader && (0, import_children.isChildOfType)(stackHeader, import_stack_utils.StackHeaderComponent)) {
				var headerProps = { children: stackHeader };
				result = (0, import_stack_utils.appendScreenStackPropsToOptions)(result, headerProps);
			}
			return result;
		};
		if (screenOptions) {
			if (typeof screenOptions === "function") {
				return function() {
					for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
						args[_key] = arguments[_key];
					}
					var opts = screenOptions(...args);
					return applyComposition(opts);
				};
			}
			return applyComposition(screenOptions);
		}
		return applyComposition({});
	}, [children, screenOptions]);
	var processedChildren = (0, import_react.useMemo)(function() {
		return mapChildren(children);
	}, [children]);
	var navigatorProps = (0, import_react.useMemo)(function() {
		return (0, import_stack_navigator.getStackNavigatorProps)(children);
	}, [children]);
	return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(RNStack, {
		...rest,
		...navigatorProps,
		ref,
		screenOptions: screenOptionsWithHeader,
		children: processedChildren
	});
});
var StackToolbar = Object.assign(import_stack_utils.StackToolbarComponent, {
	Button: import_stack_utils.StackToolbarButton,
	Menu: import_stack_utils.StackToolbarMenu,
	MenuAction: import_stack_utils.StackToolbarMenuAction,
	Spacer: import_stack_utils.StackToolbarSpacer,
	SearchBarSlot: import_stack_utils.StackToolbarSearchBarSlot,
	Label: import_stack_utils.StackToolbarLabel,
	Icon: import_stack_utils.StackToolbarIcon,
	Badge: import_stack_utils.StackToolbarBadge
});
var Stack = Object.assign(StackWithComposition, {
	Screen: import_stack_utils.StackScreen,
	Header: import_stack_utils.StackHeader,
	Toolbar: StackToolbar,
	Protected: import_Protected.Protected,
	SearchBar: import_stack_utils.StackHeaderSearchBar
});
var Stack_default = Stack;

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