one/dist/esm/fork/useLinking.native.js

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

import { getActionFromState, getStateFromPath, useNavigationIndependentTree } from "@react-navigation/core";
import * as React from "react";
import { Linking, Platform } from "react-native";
import { getNavigateAction } from "../router/utils/getNavigateAction.native.js";
import { extractPathFromURL } from "./extractPathFromURL.native.js";

var linkingHandlers = /* @__PURE__ */ new Set();
function stripRouteKeys(state) {
	return {
		...state,
		routes: state.routes.map(function(route) {
			var { key, ...rest } = route;
			return rest.state ? {
				...rest,
				state: stripRouteKeys(rest.state)
			} : rest;
		})
	};
}
function useLinking(ref, param) {
	var { enabled = true, prefixes, filter, config, getInitialURL = function() {
		return Promise.race([Linking.getInitialURL(), new Promise(function(resolve) {
			setTimeout(resolve, 150);
		})]);
	}, subscribe = function(listener) {
		var _Linking_removeEventListener;
		var callback = function callback2(param2) {
			var { url } = param2;
			return listener(url);
		};
		var subscription = Linking.addEventListener("url", callback);
		var removeEventListener = (_Linking_removeEventListener = Linking.removeEventListener) === null || _Linking_removeEventListener === void 0 ? void 0 : _Linking_removeEventListener.bind(Linking);
		return function() {
			if (subscription === null || subscription === void 0 ? void 0 : subscription.remove) {
				subscription.remove();
			} else {
				removeEventListener === null || removeEventListener === void 0 ? void 0 : removeEventListener("url", callback);
			}
		};
	}, getStateFromPath: getStateFromPath$1 = getStateFromPath, getActionFromState: getActionFromState$1 = getActionFromState } = param;
	var independent = useNavigationIndependentTree();
	React.useEffect(function() {
		if (process.env.NODE_ENV === "production") {
			return void 0;
		}
		if (independent) {
			return void 0;
		}
		if (enabled !== false && linkingHandlers.size && Platform.OS !== "android") {
			if (linkingHandlers.size > 1) {
				console.error([
					"Looks like you have configured linking in multiple places. This is likely an error since deep links should only be handled in one place to avoid conflicts. Make sure that:",
					"- You don't have multiple NavigationContainers in the app each with 'linking' enabled",
					"- Only a single instance of the root component is rendered"
				].join("\n").trim());
			}
		}
		var handler = /* @__PURE__ */ Symbol();
		if (enabled !== false) {
			linkingHandlers.add(handler);
		}
		return function() {
			linkingHandlers.delete(handler);
		};
	}, [enabled, independent]);
	var enabledRef = React.useRef(enabled);
	var prefixesRef = React.useRef(prefixes);
	var filterRef = React.useRef(filter);
	var configRef = React.useRef(config);
	var getInitialURLRef = React.useRef(getInitialURL);
	var getStateFromPathRef = React.useRef(getStateFromPath$1);
	var getActionFromStateRef = React.useRef(getActionFromState$1);
	React.useEffect(function() {
		enabledRef.current = enabled;
		prefixesRef.current = prefixes;
		filterRef.current = filter;
		configRef.current = config;
		getInitialURLRef.current = getInitialURL;
		getStateFromPathRef.current = getStateFromPath$1;
		getActionFromStateRef.current = getActionFromState$1;
	});
	var getStateFromURL = React.useCallback(function(url) {
		var _prefixesRef_current;
		if (!url || filterRef.current && !filterRef.current(url)) {
			return void 0;
		}
		var path = extractPathFromURL((_prefixesRef_current = prefixesRef.current) !== null && _prefixesRef_current !== void 0 ? _prefixesRef_current : [], url);
		return path !== void 0 ? getStateFromPathRef.current(path, configRef.current) : void 0;
	}, []);
	var getInitialState = React.useCallback(function() {
		var state;
		if (enabledRef.current) {
			var url = getInitialURLRef.current();
			if (url != null) {
				if (typeof url !== "string") {
					return url.then(function(url2) {
						return getStateFromURL(url2);
					});
				}
			}
			state = getStateFromURL(url);
		}
		var thenable = {
			then(onfulfilled) {
				return Promise.resolve(onfulfilled ? onfulfilled(state) : state);
			},
			catch() {
				return thenable;
			}
		};
		return thenable;
	}, [getStateFromURL]);
	React.useEffect(function() {
		var listener = function listener2(url) {
			if (!enabled) {
				return;
			}
			var navigation = ref.current;
			var state = navigation ? getStateFromURL(url) : void 0;
			if (navigation && state) {
				var rootState = navigation.getRootState();
				if (state.routes.some(function(r) {
					var _rootState_routeNames;
					return !(rootState === null || rootState === void 0 ? void 0 : (_rootState_routeNames = rootState.routeNames) === null || _rootState_routeNames === void 0 ? void 0 : _rootState_routeNames.includes(r.name));
				})) {
					return;
				}
				var action = getActionFromStateRef.current === getActionFromState ? rootState ? getNavigateAction(state, rootState) : void 0 : getActionFromStateRef.current(stripRouteKeys(state), configRef.current);
				if (action !== void 0) {
					try {
						navigation.dispatch(action);
					} catch (e) {
						console.warn(`An error occurred when trying to handle the link '${url}': ${typeof e === "object" && e != null && "message" in e ? e.message : e}`);
					}
				} else {
					navigation.resetRoot(state);
				}
			}
		};
		return subscribe(listener);
	}, [
		enabled,
		getStateFromURL,
		ref,
		subscribe
	]);
	return { getInitialState };
}

export { useLinking };
//# sourceMappingURL=useLinking.native.js.map