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

One is a new React Framework that makes Vite serve both native and web.

import { getActionFromState as getActionFromStateDefault, getStateFromPath as getStateFromPathDefault, useNavigationIndependentTree } from "@react-navigation/core";
import * as React from "react";
import { Linking, Platform } from "react-native";
import { extractPathFromURL } from "./extractPathFromURL.native.js";
function _type_of(obj) {
  "@swc/helpers - typeof";

  return obj && typeof Symbol < "u" && obj.constructor === Symbol ? "symbol" : typeof obj;
}
var linkingHandlers = [];
function useLinking(ref, param, onUnhandledLinking) {
  var {
      enabled = !0,
      prefixes,
      filter,
      config,
      getInitialURL = function () {
        return Promise.race([Linking.getInitialURL(), new Promise(function (resolve) {
          setTimeout(resolve, 150);
        })]);
      },
      subscribe = function (listener) {
        var _Linking_removeEventListener,
          callback = function (param2) {
            var {
              url
            } = param2;
            return listener(url);
          },
          subscription = Linking.addEventListener("url", callback),
          removeEventListener = (_Linking_removeEventListener = Linking.removeEventListener) === null || _Linking_removeEventListener === void 0 ? void 0 : _Linking_removeEventListener.bind(Linking);
        return function () {
          subscription?.remove ? subscription.remove() : removeEventListener?.("url", callback);
        };
      },
      getStateFromPath = getStateFromPathDefault,
      getActionFromState = getActionFromStateDefault
    } = param,
    independent = useNavigationIndependentTree();
  React.useEffect(function () {
    if (process.env.NODE_ENV !== "production" && !independent) {
      enabled !== !1 && linkingHandlers.length && 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", Platform.OS === "android" ? "- You have set 'android:launchMode=singleTask' in the '<activity />' section of the 'AndroidManifest.xml' file to avoid launching multiple instances" : ""].join(`
`).trim());
      var handler = Symbol();
      return enabled !== !1 && linkingHandlers.push(handler), function () {
        var index = linkingHandlers.indexOf(handler);
        index > -1 && linkingHandlers.splice(index, 1);
      };
    }
  }, [enabled, independent]);
  var enabledRef = React.useRef(enabled),
    prefixesRef = React.useRef(prefixes),
    filterRef = React.useRef(filter),
    configRef = React.useRef(config),
    getInitialURLRef = React.useRef(getInitialURL),
    getStateFromPathRef = React.useRef(getStateFromPath),
    getActionFromStateRef = React.useRef(getActionFromState);
  React.useEffect(function () {
    enabledRef.current = enabled, prefixesRef.current = prefixes, filterRef.current = filter, configRef.current = config, getInitialURLRef.current = getInitialURL, getStateFromPathRef.current = getStateFromPath, getActionFromStateRef.current = getActionFromState;
  });
  var getStateFromURL = React.useCallback(function (url) {
      if (!(!url || filterRef.current && !filterRef.current(url))) {
        var path = extractPathFromURL(prefixesRef.current, url);
        return path !== void 0 ? getStateFromPathRef.current(path, configRef.current) : void 0;
      }
    }, []),
    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) {
            var state2 = getStateFromURL(url2);
            return typeof url2 == "string" && onUnhandledLinking(extractPathFromURL(prefixes, url2)), state2;
          });
          onUnhandledLinking(extractPathFromURL(prefixes, url));
        }
        state = getStateFromURL(url);
      }
      var thenable = {
        // biome-ignore lint/suspicious/noThenProperty: don't check copied code
        then(onfulfilled) {
          return Promise.resolve(onfulfilled ? onfulfilled(state) : state);
        },
        catch() {
          return thenable;
        }
      };
      return thenable;
    }, [getStateFromURL, onUnhandledLinking, prefixes]);
  return React.useEffect(function () {
    var listener = function (url) {
      if (enabled) {
        var navigation = ref.current,
          state = navigation ? getStateFromURL(url) : void 0;
        if (navigation && state) {
          onUnhandledLinking(extractPathFromURL(prefixes, url));
          var rootState = navigation.getRootState();
          if (state.routes.some(function (r) {
            var _rootState_routeNames;
            return !(!(rootState == null || (_rootState_routeNames = rootState.routeNames) === null || _rootState_routeNames === void 0) && _rootState_routeNames.includes(r.name));
          })) return;
          var action = getActionFromStateRef.current(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 > "u" ? "undefined" : _type_of(e)) === "object" && e != null && "message" in e ? e.message : e}`);
          } else navigation.resetRoot(state);
        }
      }
    };
    return subscribe(listener);
  }, [enabled, getStateFromURL, onUnhandledLinking, prefixes, ref, subscribe]), {
    getInitialState
  };
}
export { useLinking };
//# sourceMappingURL=useLinking.native.js.map