bleam 0.0.6 → 0.0.8

package/dist/window.cjs

@@ -0,0 +1,596 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+const require_native_runtime = require('./native-runtime-CsXnXkQn.cjs');
+let react = require("react");
+react = require_chunk.__toESM(react);
+let react_native = require("react-native");
+react_native = require_chunk.__toESM(react_native);
+let react_jsx_runtime = require("react/jsx-runtime");
+react_jsx_runtime = require_chunk.__toESM(react_jsx_runtime);
+
+//#region src/native-macos.ts
+function macOSApplication() {
+	return require_native_runtime.ensureNativeScript().getClass("NSApplication")?.sharedApplication;
+}
+function createMacOSToolbar(identifier) {
+	const toolbarClass = require_native_runtime.ensureNativeScript().getClass("NSToolbar");
+	if (!toolbarClass) return;
+	try {
+		const toolbar = toolbarClass.alloc?.().initWithIdentifier?.(identifier);
+		if (toolbar) return toolbar;
+	} catch {}
+	try {
+		return toolbarClass.new?.();
+	} catch {}
+}
+
+//#endregion
+//#region src/safe-area.ts
+const emptyInsets = {
+	top: 0,
+	right: 0,
+	bottom: 0,
+	left: 0
+};
+const contributions = /* @__PURE__ */ new Map();
+const listeners = /* @__PURE__ */ new Set();
+let currentInsets = emptyInsets;
+function mergeInsets() {
+	const nextInsets = { ...emptyInsets };
+	for (const contribution of contributions.values()) {
+		nextInsets.top += contribution.top ?? 0;
+		nextInsets.right += contribution.right ?? 0;
+		nextInsets.bottom += contribution.bottom ?? 0;
+		nextInsets.left += contribution.left ?? 0;
+	}
+	return nextInsets;
+}
+function areInsetsEqual(a, b) {
+	return a.top === b.top && a.right === b.right && a.bottom === b.bottom && a.left === b.left;
+}
+function emitIfChanged(nextInsets) {
+	if (areInsetsEqual(currentInsets, nextInsets)) return;
+	currentInsets = nextInsets;
+	for (const listener of listeners) listener();
+}
+function subscribe(listener) {
+	listeners.add(listener);
+	return () => {
+		listeners.delete(listener);
+	};
+}
+function snapshot() {
+	return currentInsets;
+}
+function setSafeAreaContribution(source, contribution) {
+	contributions.set(source, contribution);
+	emitIfChanged(mergeInsets());
+}
+function clearSafeAreaContribution(source) {
+	contributions.delete(source);
+	emitIfChanged(mergeInsets());
+}
+function useSafeAreaInsets() {
+	return (0, react.useSyncExternalStore)(subscribe, snapshot, snapshot);
+}
+
+//#endregion
+//#region src/chrome.tsx
+const toolbarStyleValues = {
+	automatic: 0,
+	expanded: 1,
+	preference: 2,
+	unified: 3,
+	unifiedCompact: 4
+};
+const toolbarSafeAreaHeights = {
+	automatic: 52,
+	expanded: 52,
+	preference: 52,
+	unified: 52,
+	unifiedCompact: 38
+};
+const toolbarSafeAreaSource = "toolbar";
+const titleVisibilityValues = {
+	visible: 0,
+	hidden: 1
+};
+const userInterfaceStyleValues = {
+	automatic: 0,
+	light: 1,
+	dark: 2
+};
+function nativeRecord(value) {
+	if (!value || typeof value !== "object") return;
+	return value;
+}
+function macOSScene(value) {
+	return nativeRecord(value);
+}
+function macOSWindow(value) {
+	return nativeRecord(value);
+}
+function selectorTarget(value) {
+	return nativeRecord(value);
+}
+function setNativeValue(value, key, nextValue) {
+	const record = nativeRecord(value);
+	if (!record) return false;
+	record[key] = nextValue;
+	return true;
+}
+function colorFromHex(hex) {
+	const value = hex.trim().replace(/^#/, "");
+	const normalized = value.length === 3 ? value.split("").map((part) => `${part}${part}`).join("") : value;
+	if (!/^[\da-f]{6}$/i.test(normalized)) throw new Error(`Invalid color: ${hex}`);
+	const number = Number.parseInt(normalized, 16);
+	const red = (number >> 16 & 255) / 255;
+	const green = (number >> 8 & 255) / 255;
+	const blue = (number & 255) / 255;
+	return UIColor.colorWithRedGreenBlueAlpha(red, green, blue, 1);
+}
+function forEachNativeObject(collection, callback) {
+	const values = collection?.allObjects ?? collection;
+	if (Array.isArray(values)) {
+		values.forEach(callback);
+		return;
+	}
+	const iterableValues = values;
+	const count = Number(iterableValues?.count ?? 0);
+	for (let index = 0; index < count; index += 1) callback(iterableValues?.objectAtIndex?.(index));
+}
+function runOnUIWithRetry(apply) {
+	const run = () => require_native_runtime.ensureNativeScript().runOnUI(apply).catch(() => {});
+	run();
+	const timeout = setTimeout(() => {
+		run();
+	}, 250);
+	return () => {
+		clearTimeout(timeout);
+	};
+}
+function applyWindowTitle(title) {
+	const application = UIApplication.sharedApplication;
+	forEachNativeObject(application?.connectedScenes, (scene) => {
+		setNativeValue(scene, "title", title);
+	});
+	const appKitApplication = macOSApplication();
+	const appKitWindow = appKitApplication?.keyWindow ?? appKitApplication?.mainWindow;
+	if (appKitWindow) setNativeValue(appKitWindow, "title", title);
+}
+function clearRootView(window) {
+	const rootView = (macOSWindow(window)?.rootViewController)?.view;
+	if (!rootView) return;
+	setNativeValue(rootView, "backgroundColor", UIColor.clearColor);
+	setNativeValue(rootView, "opaque", false);
+}
+function forEachApplicationWindow(callback) {
+	const application = UIApplication.sharedApplication;
+	callback(application.keyWindow);
+	forEachNativeObject(application?.windows, callback);
+	forEachNativeObject(application?.connectedScenes, (scene) => {
+		callback(macOSScene(scene)?.keyWindow);
+		forEachNativeObject(macOSScene(scene)?.windows, callback);
+	});
+}
+function applyWindowTint(tint) {
+	const tintColor = colorFromHex(tint);
+	function applyTint(window) {
+		if (!window) return;
+		setNativeValue(window, "tintColor", tintColor);
+		clearRootView(window);
+		const rootView = (macOSWindow(window)?.rootViewController)?.view;
+		if (rootView) setNativeValue(rootView, "tintColor", tintColor);
+	}
+	forEachApplicationWindow(applyTint);
+}
+function applyWindowBackgroundColor(backgroundColor) {
+	const color = colorFromHex(backgroundColor);
+	forEachApplicationWindow((window) => {
+		if (!window) return;
+		setNativeValue(window, "backgroundColor", color);
+		clearRootView(window);
+	});
+}
+function applyWindowUserInterfaceStyle(userInterfaceStyle) {
+	const value = userInterfaceStyleValues[userInterfaceStyle];
+	forEachApplicationWindow((window) => {
+		if (!window) return;
+		setNativeValue(window, "overrideUserInterfaceStyle", value);
+		const rootViewController = macOSWindow(window)?.rootViewController;
+		if (rootViewController) setNativeValue(rootViewController, "overrideUserInterfaceStyle", value);
+	});
+}
+function applyWindowRootTransparency() {
+	forEachApplicationWindow((window) => {
+		if (window) clearRootView(window);
+	});
+}
+function invokeNativeValue(target, selector, ...values) {
+	const invoke = selectorTarget(target)?.invoke;
+	if (typeof invoke !== "function") return;
+	return invoke.call(target, selector, ...values);
+}
+function titlebarForScene(scene) {
+	try {
+		const titlebar = invokeNativeValue(scene, "titlebar");
+		if (titlebar) return titlebar;
+	} catch {}
+	try {
+		const target = selectorTarget(scene);
+		if (target?.valueForKey) {
+			const titlebar = target.valueForKey("titlebar");
+			if (titlebar) return titlebar;
+		}
+	} catch {}
+	return macOSScene(scene)?.titlebar;
+}
+function setNativeNumber(target, key, value) {
+	const selector = `set${key[0]?.toUpperCase()}${key.slice(1)}:`;
+	try {
+		if (invokeNativeValue(target, selector, value) !== void 0) return;
+	} catch {}
+	try {
+		if (setNativeValue(target, key, value)) return;
+	} catch {}
+	try {
+		const selector$1 = selectorTarget(target);
+		if (selector$1?.setValueForKey) {
+			selector$1.setValueForKey(NSNumber.numberWithInteger(value), key);
+			return;
+		}
+	} catch {}
+}
+function applyTitleVisibility(titleVisibility) {
+	if (!macOSApplication()) return;
+	const value = titleVisibilityValues[titleVisibility];
+	const application = UIApplication.sharedApplication;
+	forEachNativeObject(application?.connectedScenes, (scene) => {
+		const titlebar = titlebarForScene(scene);
+		if (!titlebar) return;
+		setNativeNumber(titlebar, "titleVisibility", value);
+	});
+}
+function toolbarForTitlebar(titlebar) {
+	let toolbar;
+	try {
+		toolbar = invokeNativeValue(titlebar, "toolbar");
+	} catch {}
+	try {
+		toolbar ??= titlebar.toolbar;
+	} catch {}
+	try {
+		if (!toolbar && titlebar.valueForKey) toolbar = titlebar.valueForKey("toolbar");
+	} catch {}
+	if (toolbar) return toolbar;
+	toolbar = createMacOSToolbar("BleamToolbar");
+	if (!toolbar) return;
+	try {
+		if (invokeNativeValue(titlebar, "setToolbar:", toolbar) !== void 0) return toolbar;
+	} catch {}
+	try {
+		if (setNativeValue(titlebar, "toolbar", toolbar)) return toolbar;
+	} catch {}
+	try {
+		if (titlebar.setValueForKey) {
+			titlebar.setValueForKey(toolbar, "toolbar");
+			return toolbar;
+		}
+	} catch {}
+}
+function applyToolbarStyle(toolbarStyle) {
+	if (!macOSApplication()) return;
+	const value = toolbarStyleValues[toolbarStyle];
+	const application = UIApplication.sharedApplication;
+	forEachNativeObject(application?.connectedScenes, (scene) => {
+		const titlebar = titlebarForScene(scene);
+		if (!titlebar) return;
+		toolbarForTitlebar(titlebar);
+		setNativeNumber(titlebar, "toolbarStyle", value);
+	});
+}
+function Window(props) {
+	const { title, tint, backgroundColor, userInterfaceStyle, titleVisibility } = props;
+	(0, react.useLayoutEffect)(() => {
+		return runOnUIWithRetry(() => {
+			applyWindowRootTransparency();
+		});
+	}, []);
+	(0, react.useEffect)(() => {
+		if (title === void 0) return;
+		require_native_runtime.ensureNativeScript().runOnUI(() => {
+			applyWindowTitle(title);
+		}).catch(() => {});
+	}, [title]);
+	(0, react.useLayoutEffect)(() => {
+		if (tint === void 0) return;
+		return runOnUIWithRetry(() => {
+			applyWindowTint(tint);
+		});
+	}, [tint]);
+	(0, react.useLayoutEffect)(() => {
+		if (backgroundColor === void 0) return;
+		return runOnUIWithRetry(() => {
+			applyWindowBackgroundColor(backgroundColor);
+		});
+	}, [backgroundColor]);
+	(0, react.useLayoutEffect)(() => {
+		if (userInterfaceStyle === void 0) return;
+		return runOnUIWithRetry(() => {
+			applyWindowUserInterfaceStyle(userInterfaceStyle);
+		});
+	}, [userInterfaceStyle]);
+	(0, react.useEffect)(() => {
+		if (titleVisibility === void 0) return;
+		require_native_runtime.ensureNativeScript().runOnUI(() => {
+			applyTitleVisibility(titleVisibility);
+		}).catch(() => {});
+	}, [titleVisibility]);
+	return null;
+}
+function Toolbar(props) {
+	const { toolbarStyle } = props;
+	(0, react.useEffect)(() => {
+		if (toolbarStyle === void 0) {
+			clearSafeAreaContribution(toolbarSafeAreaSource);
+			return;
+		}
+		setSafeAreaContribution(toolbarSafeAreaSource, { top: toolbarSafeAreaHeights[toolbarStyle] });
+		require_native_runtime.ensureNativeScript().runOnUI(() => {
+			applyToolbarStyle(toolbarStyle);
+		}).catch(() => {});
+		return () => {
+			clearSafeAreaContribution(toolbarSafeAreaSource);
+		};
+	}, [toolbarStyle]);
+	return null;
+}
+
+//#endregion
+//#region src/navigation.tsx
+const stateKey = Symbol.for("bleam.navigation.sidebar");
+const sectionIdentifier = "sidebar";
+const splitIdentifier = "bleam.navigation.sidebar.split";
+const defaultMinimumSidebarWidth = 180;
+const defaultSidebarWidth = 240;
+const defaultMaximumSidebarWidth = 320;
+const MissingContext = Symbol("MissingContext");
+const sidebarSafeAreaSource = "sidebar";
+function sidebarState() {
+	const globalState = globalThis;
+	globalState[stateKey] ??= {
+		items: [],
+		titleById: /* @__PURE__ */ new Map(),
+		symbolById: /* @__PURE__ */ new Map(),
+		sidebarWidth: defaultSidebarWidth,
+		minimumSidebarWidth: defaultMinimumSidebarWidth,
+		maximumSidebarWidth: defaultMaximumSidebarWidth
+	};
+	return globalState[stateKey];
+}
+function isClassAvailable(name) {
+	const nativeScript = require_native_runtime.ensureNativeScript();
+	return nativeScript.isClassAvailable?.(name) ?? Boolean(nativeScript.getClass(name));
+}
+function requiredNativeClassesAvailable() {
+	return [
+		"UISplitViewController",
+		"UICollectionLayoutListConfiguration",
+		"UICollectionViewCompositionalLayout",
+		"UICollectionView",
+		"UICollectionViewListCell",
+		"UICollectionViewCellRegistration",
+		"UICollectionViewDiffableDataSource",
+		"NSDiffableDataSourceSnapshot"
+	].every(isClassAvailable);
+}
+function createSidebarController(state) {
+	const listConfiguration = UICollectionLayoutListConfiguration.alloc().initWithAppearance(UICollectionLayoutListAppearance.Sidebar);
+	listConfiguration.showsSeparators = false;
+	const layout = UICollectionViewCompositionalLayout.layoutWithListConfiguration(listConfiguration);
+	const collectionView = UICollectionView.alloc().initWithFrameCollectionViewLayout(CGRectZero, layout);
+	collectionView.backgroundColor = UIColor.clearColor;
+	collectionView.allowsMultipleSelection = false;
+	collectionView.allowsFocus = false;
+	collectionView.remembersLastFocusedIndexPath = false;
+	collectionView.selectionFollowsFocus = false;
+	const sidebarController = UIViewController.new();
+	sidebarController.title = "Sidebar";
+	sidebarController.view = collectionView;
+	const cellRegistration = UICollectionViewCellRegistration.registrationWithCellClassConfigurationHandler(UICollectionViewListCell, (cell, _indexPath, item) => {
+		const listCell = cell;
+		const content = listCell.defaultContentConfiguration();
+		const itemId = String(item);
+		const symbol = state.symbolById.get(itemId);
+		content.text = state.titleById.get(itemId) ?? itemId;
+		content.image = symbol ? UIImage.systemImageNamed(symbol) : null;
+		listCell.contentConfiguration = content;
+		listCell.accessories = [];
+	});
+	const dataSource = UICollectionViewDiffableDataSource.alloc().initWithCollectionViewCellProvider(collectionView, (nextCollectionView, indexPath, item) => nextCollectionView.dequeueConfiguredReusableCellWithRegistrationForIndexPathItem(cellRegistration, indexPath, item));
+	const delegate = require_native_runtime.ensureNativeScript().createDelegate(UICollectionViewDelegate, { collectionViewDidSelectItemAtIndexPath(_collectionView, indexPath) {
+		const item = state.items[indexPath.item];
+		if (!item) return;
+		state.selectedId = item.id;
+		state.emitSelect?.(item.id);
+	} });
+	collectionView.dataSource = dataSource;
+	collectionView.delegate = delegate;
+	state.sidebarViewController = sidebarController;
+	state.collectionView = collectionView;
+	state.dataSource = dataSource;
+	state.delegate = delegate;
+	state.cellRegistration = cellRegistration;
+	return sidebarController;
+}
+function isSidebarSplitController(viewController) {
+	if (!viewController) return false;
+	return viewController.restorationIdentifier === splitIdentifier && viewController.isKindOfClass(UISplitViewController);
+}
+function reuseExistingSidebarSplit(state, splitViewController) {
+	const contentViewController = splitViewController.viewControllerForColumn(UISplitViewControllerColumn.Secondary);
+	const sidebarController = createSidebarController(state);
+	splitViewController.minimumPrimaryColumnWidth = state.minimumSidebarWidth;
+	splitViewController.preferredPrimaryColumnWidth = state.sidebarWidth;
+	splitViewController.maximumPrimaryColumnWidth = state.maximumSidebarWidth;
+	splitViewController.setViewControllerForColumn(sidebarController, UISplitViewControllerColumn.Primary);
+	state.originalRootViewController = contentViewController;
+	state.splitViewController = splitViewController;
+}
+function installSidebarNavigator(state) {
+	if (state.splitViewController) return;
+	if (!requiredNativeClassesAvailable()) return;
+	const window = UIApplication.sharedApplication.keyWindow;
+	const rootViewController = window?.rootViewController;
+	if (!window || !rootViewController) return;
+	if (isSidebarSplitController(rootViewController)) {
+		reuseExistingSidebarSplit(state, rootViewController);
+		return;
+	}
+	const sidebarController = createSidebarController(state);
+	const splitViewController = UISplitViewController.alloc().initWithStyle(UISplitViewControllerStyle.DoubleColumn);
+	splitViewController.restorationIdentifier = splitIdentifier;
+	splitViewController.primaryBackgroundStyle = UISplitViewControllerBackgroundStyle.Sidebar;
+	splitViewController.preferredSplitBehavior = UISplitViewControllerSplitBehavior.Tile;
+	splitViewController.preferredDisplayMode = UISplitViewControllerDisplayMode.OneBesideSecondary;
+	splitViewController.displayModeButtonVisibility = UISplitViewControllerDisplayModeButtonVisibility.Always;
+	splitViewController.minimumPrimaryColumnWidth = state.minimumSidebarWidth;
+	splitViewController.preferredPrimaryColumnWidth = state.sidebarWidth;
+	splitViewController.maximumPrimaryColumnWidth = state.maximumSidebarWidth;
+	splitViewController.setViewControllerForColumn(sidebarController, UISplitViewControllerColumn.Primary);
+	splitViewController.setViewControllerForColumn(rootViewController, UISplitViewControllerColumn.Secondary);
+	state.originalRootViewController = rootViewController;
+	state.splitViewController = splitViewController;
+	window.rootViewController = splitViewController;
+	window.makeKeyAndVisible();
+}
+function applySidebarSnapshot(state) {
+	const { dataSource } = state;
+	if (!dataSource) return;
+	const snapshot$1 = NSDiffableDataSourceSnapshot.alloc().init();
+	snapshot$1.appendSectionsWithIdentifiers([sectionIdentifier]);
+	snapshot$1.appendItemsWithIdentifiersIntoSectionWithIdentifier(state.items.map((item) => item.id), sectionIdentifier);
+	dataSource.applySnapshotAnimatingDifferences(snapshot$1, true);
+}
+function applySidebarSelection(state) {
+	const { collectionView, selectedId } = state;
+	if (!collectionView || selectedId === void 0) return;
+	const itemIndex = state.items.findIndex((item) => item.id === selectedId);
+	if (itemIndex < 0) return;
+	const indexPath = NSIndexPath.indexPathForItemInSection(itemIndex, 0);
+	collectionView.selectItemAtIndexPathAnimatedScrollPosition(indexPath, false, UICollectionViewScrollPosition.None);
+}
+function applySidebarNavigator(props, ctx) {
+	const state = sidebarState();
+	state.items = props.items;
+	state.selectedId = props.selectedId;
+	state.emitSelect = props.onSelect ? (id) => ctx?.emit("onSelect", id) : void 0;
+	state.sidebarWidth = props.sidebarWidth ?? defaultSidebarWidth;
+	state.minimumSidebarWidth = props.minimumSidebarWidth ?? defaultMinimumSidebarWidth;
+	state.maximumSidebarWidth = props.maximumSidebarWidth ?? defaultMaximumSidebarWidth;
+	state.titleById = new Map(props.items.map((item) => [item.id, item.title]));
+	state.symbolById = new Map(props.items.filter((item) => Boolean(item.symbol)).map((item) => [item.id, item.symbol]));
+	installSidebarNavigator(state);
+	applySidebarSnapshot(state);
+	applySidebarSelection(state);
+}
+const NativeSidebarNavigator = require_native_runtime.ensureNativeScript().defineUIKitView({
+	name: "NativeSidebarNavigator",
+	layout: {
+		sizing: "fill",
+		defaultSize: {
+			width: 0,
+			height: 0
+		}
+	},
+	create(ctx) {
+		const view = UIView.new();
+		view.hidden = true;
+		applySidebarNavigator(ctx, ctx);
+		return view;
+	},
+	update(_view, props, _previousProps, ctx) {
+		applySidebarNavigator(props, ctx);
+	}
+});
+function screenComponent(config) {
+	return typeof config === "function" ? config : config.screen;
+}
+function screenTitle(name, config) {
+	return typeof config === "function" ? name : config.title ?? name;
+}
+function screenSymbol(config) {
+	return typeof config === "function" ? void 0 : config.symbol;
+}
+function createSidebarNavigator(config) {
+	const context = (0, react.createContext)(MissingContext);
+	const items = Object.entries(config.screens).map(([name, screen]) => ({
+		id: name,
+		title: screenTitle(name, screen),
+		symbol: screenSymbol(screen)
+	}));
+	const sidebarWidth = config.sidebarWidth ?? defaultSidebarWidth;
+	function useNavigatorContext() {
+		const value = (0, react.useContext)(context);
+		if (value === MissingContext) throw new Error("Expected a Bleam sidebar navigation context");
+		return value;
+	}
+	function Navigator() {
+		const [routeName, setRouteName] = (0, react.useState)(config.initialRouteName);
+		const navigate = (0, react.useCallback)((name) => {
+			if (name in config.screens) setRouteName(name);
+		}, []);
+		const route = (0, react.useMemo)(() => ({ name: routeName }), [routeName]);
+		const navigation = (0, react.useMemo)(() => ({
+			route,
+			navigate
+		}), [route, navigate]);
+		const value = (0, react.useMemo)(() => ({
+			route,
+			navigation
+		}), [route, navigation]);
+		const activeScreen = config.screens[routeName];
+		const ActiveScreen = activeScreen ? screenComponent(activeScreen) : void 0;
+		(0, react.useEffect)(() => {
+			setSafeAreaContribution(sidebarSafeAreaSource, { left: sidebarWidth });
+			return () => {
+				clearSafeAreaContribution(sidebarSafeAreaSource);
+			};
+		}, []);
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(context.Provider, {
+			value,
+			children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_native.View, {
+				style: [{
+					flex: 1,
+					paddingLeft: sidebarWidth
+				}, config.style],
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(NativeSidebarNavigator, {
+					items,
+					selectedId: routeName,
+					sidebarWidth,
+					minimumSidebarWidth: config.minimumSidebarWidth,
+					maximumSidebarWidth: config.maximumSidebarWidth,
+					onSelect: (name) => {
+						if (name in config.screens) navigate(name);
+					}
+				}), ActiveScreen ? (0, react.createElement)(ActiveScreen, {}) : null]
+			})
+		});
+	}
+	function useNavigation() {
+		return useNavigatorContext().navigation;
+	}
+	function useRoute() {
+		return useNavigatorContext().route;
+	}
+	return {
+		Navigator,
+		useNavigation,
+		useRoute
+	};
+}
+
+//#endregion
+exports.Toolbar = Toolbar;
+exports.Window = Window;
+exports.createSidebarNavigator = createSidebarNavigator;
+exports.useSafeAreaInsets = useSafeAreaInsets;

package/dist/window.d.cts

@@ -0,0 +1,63 @@
+import { p as SymbolName } from "./ui-1WepaMS4.cjs";
+import * as react3 from "react";
+import { ComponentType } from "react";
+import { StyleProp, ViewStyle } from "react-native";
+
+//#region src/chrome.d.ts
+type HexColor = `#${string}`;
+type WindowToolbarStyle = 'automatic' | 'unified' | 'unifiedCompact' | 'preference' | 'expanded';
+type WindowTitleVisibility = 'visible' | 'hidden';
+type WindowUserInterfaceStyle = 'automatic' | 'light' | 'dark';
+type WindowProps = {
+  title?: string;
+  tint?: HexColor;
+  backgroundColor?: HexColor;
+  userInterfaceStyle?: WindowUserInterfaceStyle;
+  titleVisibility?: WindowTitleVisibility;
+};
+type ToolbarProps = {
+  toolbarStyle?: WindowToolbarStyle;
+};
+declare function Window(props: WindowProps): null;
+declare function Toolbar(props: ToolbarProps): null;
+//#endregion
+//#region src/safe-area.d.ts
+type SafeAreaInsets = {
+  top: number;
+  right: number;
+  bottom: number;
+  left: number;
+};
+declare function useSafeAreaInsets(): SafeAreaInsets;
+//#endregion
+//#region src/navigation.d.ts
+type RouteName = string;
+type ScreenComponent = ComponentType<Record<string, never>>;
+type SidebarScreenConfig = ScreenComponent | {
+  screen: ScreenComponent;
+  title?: string;
+  symbol?: SymbolName;
+};
+type SidebarScreenMap = Record<RouteName, SidebarScreenConfig>;
+type SidebarRouteState<Routes extends SidebarScreenMap> = {
+  name: Extract<keyof Routes, string>;
+};
+type SidebarNavigation<Routes extends SidebarScreenMap> = {
+  route: SidebarRouteState<Routes>;
+  navigate(name: Extract<keyof Routes, string>): void;
+};
+type SidebarNavigatorConfig<Routes extends SidebarScreenMap> = {
+  initialRouteName: Extract<keyof Routes, string>;
+  screens: Routes;
+  sidebarWidth?: number;
+  minimumSidebarWidth?: number;
+  maximumSidebarWidth?: number;
+  style?: StyleProp<ViewStyle>;
+};
+declare function createSidebarNavigator<const Routes extends SidebarScreenMap>(config: SidebarNavigatorConfig<Routes>): {
+  Navigator: () => react3.JSX.Element;
+  useNavigation: () => SidebarNavigation<Routes>;
+  useRoute: () => SidebarRouteState<Routes>;
+};
+//#endregion
+export { type HexColor, type SafeAreaInsets, type SidebarNavigatorConfig, Toolbar, type ToolbarProps, Window, type WindowProps, type WindowTitleVisibility, type WindowToolbarStyle, type WindowUserInterfaceStyle, createSidebarNavigator, useSafeAreaInsets };