one 1.1.320 → 1.1.321

package/dist/cjs/fork/getStateFromPath.js

@@ -0,0 +1,381 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var getStateFromPath_exports = {};
+__export(getStateFromPath_exports, {
+  default: () => getStateFromPath,
+  getMatchableRouteConfigs: () => getMatchableRouteConfigs,
+  getUrlWithReactNavigationConcessions: () => getUrlWithReactNavigationConcessions,
+  stripBaseUrl: () => stripBaseUrl
+});
+module.exports = __toCommonJS(getStateFromPath_exports);
+var import_escape_string_regexp = __toESM(require("escape-string-regexp"), 1), import_matchers = require("../matchers"), import_findFocusedRoute = require("./findFocusedRoute"), import_validatePathConfig = __toESM(require("./validatePathConfig"), 1);
+function getUrlWithReactNavigationConcessions(path, baseUrl = process.env.EXPO_BASE_URL) {
+  let parsed;
+  try {
+    parsed = new URL(path, baseUrl || "http://phony.example");
+  } catch (err) {
+    return console.warn(`Error parsing url ${path}: ${err?.message}`), {
+      nonstandardPathname: path,
+      inputPathnameWithoutHash: path.replace(/#.*$/g, ""),
+      url: null
+    };
+  }
+  const pathname = parsed.pathname;
+  return {
+    // The slashes are at the end, not the beginning
+    nonstandardPathname: stripBaseUrl(pathname, baseUrl).replace(/^\/+/g, "").replace(/\/+$/g, "") + "/",
+    url: parsed
+  };
+}
+function getStateFromPath(path, options) {
+  const { initialRoutes, configs } = getMatchableRouteConfigs(options);
+  return getStateFromPathWithConfigs(path, configs, initialRoutes);
+}
+function getMatchableRouteConfigs(options) {
+  options && (0, import_validatePathConfig.default)(options);
+  const screens = options?.screens;
+  if (!screens)
+    throw Error("You must pass a 'screens' object to 'getStateFromPath' to generate a path.");
+  const initialRoutes = [];
+  options?.initialRouteName && initialRoutes.push({
+    initialRouteName: options.initialRouteName,
+    parentScreens: []
+  });
+  const converted = Object.keys(screens).flatMap((key) => createNormalizedConfigs(key, screens, [], initialRoutes)).flat(), resolvedInitialPatterns = initialRoutes.map(
+    (route) => joinPaths(...route.parentScreens, route.initialRouteName)
+  ), configs = converted.map((config) => ({
+    ...config,
+    // TODO: Probably a safer way to do this
+    // Mark initial routes to give them potential priority over other routes that match.
+    isInitial: resolvedInitialPatterns.includes(config.routeNames.join("/"))
+  })).sort(sortConfigs);
+  return assertConfigDuplicates(configs), { configs, initialRoutes };
+}
+function assertConfigDuplicates(configs) {
+  configs.reduce((acc, config) => {
+    const indexedKey = config.regex?.toString() ?? config.pattern, alpha = acc[indexedKey];
+    if (alpha && !alpha.hasChildren && !config.hasChildren) {
+      const a = alpha.routeNames, b = config.routeNames;
+      if (!(a.length > b.length ? b.every((it, i) => a[i] === it) : a.every((it, i) => b[i] === it))) {
+        const last = config.pattern.split("/").pop();
+        if (!last?.match(/^\*not-found$/)) {
+          const routeType = last?.startsWith(":") ? "dynamic route" : last?.startsWith("*") ? "dynamic-rest route" : "route";
+          throw new Error(
+            `The ${routeType} pattern '${config.pattern || "/"}' resolves to both '${alpha.userReadableName}' and '${config.userReadableName}'. Patterns must be unique and cannot resolve to more than one route.`
+          );
+        }
+      }
+    }
+    return Object.assign(acc, {
+      [indexedKey]: config
+    });
+  }, {});
+}
+function sortConfigs(a, b) {
+  if (a.pattern === b.pattern)
+    return b.routeNames.join(">").localeCompare(a.routeNames.join(">"));
+  if (a.pattern.startsWith(b.pattern) && // NOTE: This is a hack to make sure that `*` is always at the end
+  b.screen !== "index")
+    return -1;
+  if (b.pattern.startsWith(a.pattern) && a.screen !== "index")
+    return 1;
+  const aParts = a.pattern.split("/").filter((part) => (0, import_matchers.matchGroupName)(part) == null);
+  (a.screen === "index" || a.screen.match(/\/index$/)) && aParts.push("index");
+  const bParts = b.pattern.split("/").filter((part) => (0, import_matchers.matchGroupName)(part) == null);
+  (b.screen === "index" || b.screen.match(/\/index$/)) && bParts.push("index");
+  for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+    if (aParts[i] == null)
+      return 1;
+    if (bParts[i] == null)
+      return -1;
+    const aWildCard = aParts[i].startsWith("*"), bWildCard = bParts[i].startsWith("*");
+    if (aWildCard && bWildCard) {
+      const aNotFound = aParts[i].match(/^[*]not-found$/), bNotFound = bParts[i].match(/^[*]not-found$/);
+      if (aNotFound && bNotFound)
+        continue;
+      if (aNotFound)
+        return 1;
+      if (bNotFound)
+        return -1;
+      continue;
+    }
+    if (aWildCard)
+      return 1;
+    if (bWildCard)
+      return -1;
+    const aSlug = aParts[i].startsWith(":"), bSlug = bParts[i].startsWith(":");
+    if (aSlug && bSlug) {
+      const aNotFound = aParts[i].match(/^[*]not-found$/), bNotFound = bParts[i].match(/^[*]not-found$/);
+      if (aNotFound && bNotFound)
+        continue;
+      if (aNotFound)
+        return 1;
+      if (bNotFound)
+        return -1;
+      continue;
+    }
+    if (aSlug)
+      return 1;
+    if (bSlug)
+      return -1;
+  }
+  return a.isInitial && !b.isInitial ? -1 : !a.isInitial && b.isInitial ? 1 : bParts.length - aParts.length;
+}
+function getStateFromEmptyPathWithConfigs(path, hash, configs, initialRoutes) {
+  const leafNodes = configs.filter((config) => !config.hasChildren).map((value) => ({
+    ...value,
+    // Collapse all levels of group segments before testing.
+    // This enables `app/(one)/(two)/index.js` to be matched.
+    path: (0, import_matchers.stripGroupSegmentsFromPath)(value.path)
+  })), match = leafNodes.find(
+    (config) => (
+      // NOTE: Test leaf node index routes that either don't have a regex or match an empty string.
+      config.path === "" && (!config.regex || config.regex.test(""))
+    )
+  ) ?? leafNodes.find(
+    (config) => (
+      // NOTE: Test leaf node dynamic routes that match an empty string.
+      config.path.startsWith(":") && config.regex.test("")
+    )
+  ) ?? // NOTE: Test leaf node deep dynamic routes that match a slash.
+  // This should be done last to enable dynamic routes having a higher priority.
+  leafNodes.find((config) => config.path.startsWith("*") && config.regex.test("/"));
+  if (!match)
+    return;
+  const routes = match.routeNames.map((name) => match._route ? {
+    name,
+    _route: match._route
+  } : { name });
+  return createNestedStateObject(path, hash, routes, configs, initialRoutes);
+}
+function getStateFromPathWithConfigs(path, configs, initialRoutes, baseUrl = process.env.EXPO_BASE_URL) {
+  const formattedPaths = getUrlWithReactNavigationConcessions(path);
+  if (!formattedPaths.url) {
+    console.warn(`No url found for ${path}`);
+    return;
+  }
+  let cleanPath = stripBaseUrl((0, import_matchers.stripGroupSegmentsFromPath)(formattedPaths.url.pathname), baseUrl) + formattedPaths.url.search;
+  if (path.startsWith("/") || (cleanPath = cleanPath.slice(1)), formattedPaths.nonstandardPathname === "/")
+    return getStateFromEmptyPathWithConfigs(
+      cleanPath,
+      formattedPaths.url.hash.slice(1),
+      configs,
+      initialRoutes
+    );
+  const routes = matchAgainstConfigs(formattedPaths.nonstandardPathname, configs);
+  if (routes != null)
+    return createNestedStateObject(
+      cleanPath,
+      formattedPaths.url.hash.slice(1),
+      routes,
+      configs,
+      initialRoutes
+    );
+}
+const joinPaths = (...paths) => [].concat(...paths.map((p) => p.split("/"))).filter(Boolean).join("/");
+function matchAgainstConfigs(remaining, configs) {
+  let routes, remainingPath = remaining;
+  for (const config of configs) {
+    if (!config.regex)
+      continue;
+    const match = remainingPath.match(config.regex);
+    if (!match)
+      continue;
+    const matchedParams = config.pattern?.split("/").filter((p) => p.match(/^[:*]/)).reduce((acc, p, i) => p.match(/^\*/) ? {
+      ...acc,
+      [p]: match[(i + 1) * 2]
+      //?.replace(/\//, ""),
+    } : Object.assign(acc, {
+      // The param segments appear every second item starting from 2 in the regex match result.
+      // This will only work if we ensure groups aren't included in the match.
+      [p]: match[(i + 1) * 2]?.replace(/\//, "")
+    }), {}), routeFromName = (name) => {
+      const config2 = configs.find((c) => c.screen === name);
+      if (!config2?.path)
+        return { name };
+      const segments = config2.path.split("/"), params = {};
+      return segments.filter((p) => p.match(/^[:*]/)).forEach((p) => {
+        let value = matchedParams[p];
+        if (value) {
+          p.match(/^\*/) && (value = value?.split("/").filter(Boolean));
+          const key = p.replace(/^[:*]/, "").replace(/\?$/, "");
+          params[key] = config2.parse?.[key] ? config2.parse[key](value) : value;
+        }
+      }), params && Object.keys(params).length ? { name, params } : { name };
+    };
+    routes = config.routeNames.map((name) => config._route ? {
+      ...routeFromName(name),
+      _route: config._route
+    } : { ...routeFromName(name) });
+    const combinedParams = routes.reduce(
+      (acc, r) => Object.assign(acc, r.params),
+      {}
+    ), hasCombinedParams = Object.keys(combinedParams).length > 0;
+    routes = routes.map((r) => (hasCombinedParams && (r.params = combinedParams), r)), remainingPath = remainingPath.replace(match[1], "");
+    break;
+  }
+  return routes;
+}
+function equalHeritage(a, b) {
+  if (a.length !== b.length)
+    return !1;
+  for (let i = 0; i < a.length; i++)
+    if (a[i].localeCompare(b[i]) !== 0)
+      return !1;
+  return !0;
+}
+const createNormalizedConfigs = (screen, routeConfig, routeNames = [], initials = [], parentScreens = [], parentPattern) => {
+  const configs = [];
+  routeNames.push(screen), parentScreens.push(screen);
+  const config = routeConfig[screen];
+  if (typeof config == "string") {
+    const pattern = parentPattern ? joinPaths(parentPattern, config) : config;
+    configs.push(createConfigItem(screen, routeNames, pattern, config, !1));
+  } else if (typeof config == "object") {
+    let pattern;
+    const { _route } = config;
+    if (typeof config.path == "string") {
+      if (config.exact && config.path === void 0)
+        throw new Error(
+          "A 'path' needs to be specified when specifying 'exact: true'. If you don't want this screen in the URL, specify it as empty string, e.g. `path: ''`."
+        );
+      pattern = config.exact !== !0 ? joinPaths(parentPattern || "", config.path || "") : config.path || "", configs.push(
+        createConfigItem(
+          screen,
+          routeNames,
+          pattern,
+          config.path,
+          config.screens ? !!Object.keys(config.screens)?.length : !1,
+          config.parse,
+          _route
+        )
+      );
+    }
+    config.screens && (config.initialRouteName && initials.push({
+      initialRouteName: config.initialRouteName,
+      parentScreens
+    }), Object.keys(config.screens).forEach((nestedConfig) => {
+      const result = createNormalizedConfigs(
+        nestedConfig,
+        config.screens,
+        routeNames,
+        initials,
+        [...parentScreens],
+        pattern ?? parentPattern
+      );
+      configs.push(...result);
+    }));
+  }
+  return routeNames.pop(), configs;
+};
+function formatRegexPattern(it) {
+  return it = it.replace(" ", "%20"), it.startsWith(":") ? `(([^/]+\\/)${it.endsWith("?") ? "?" : ""})` : it.startsWith("*") ? `((.*\\/)${it.endsWith("?") ? "?" : ""})` : (0, import_matchers.matchGroupName)(it) != null ? `(?:${(0, import_escape_string_regexp.default)(it)}\\/)?` : (0, import_escape_string_regexp.default)(it) + "\\/";
+}
+const createConfigItem = (screen, routeNames, pattern, path, hasChildren, parse, _route) => {
+  pattern = pattern.split("/").filter(Boolean).join("/");
+  const regex = pattern ? new RegExp(`^(${pattern.split("/").map(formatRegexPattern).join("")})$`) : void 0;
+  return {
+    screen,
+    regex,
+    pattern,
+    path,
+    // The routeNames array is mutated, so copy it to keep the current state
+    routeNames: [...routeNames],
+    parse,
+    userReadableName: [...routeNames.slice(0, -1), path || screen].join("/"),
+    hasChildren: !!hasChildren,
+    _route
+  };
+}, findParseConfigForRoute = (routeName, routeConfigs) => {
+  for (const config of routeConfigs)
+    if (routeName === config.routeNames[config.routeNames.length - 1])
+      return config.parse;
+}, findInitialRoute = (routeName, parentScreens, initialRoutes) => {
+  for (const config of initialRoutes)
+    if (equalHeritage(parentScreens, config.parentScreens))
+      return routeName !== config.initialRouteName ? config.initialRouteName : void 0;
+}, createStateObject = (route, isEmpty, initialRoute) => isEmpty ? initialRoute ? {
+  index: 1,
+  routes: [{ name: initialRoute }, route]
+} : {
+  routes: [route]
+} : initialRoute ? {
+  index: 1,
+  routes: [{ name: initialRoute }, { ...route, state: { routes: [] } }]
+} : {
+  routes: [{ ...route, state: { routes: [] } }]
+}, createNestedStateObject = (path, hash, routes, routeConfigs, initialRoutes) => {
+  let route = routes.shift();
+  const parentScreens = [];
+  let initialRoute = findInitialRoute(route.name, parentScreens, initialRoutes);
+  parentScreens.push(route.name);
+  const state = createStateObject(route, routes.length === 0, initialRoute);
+  if (routes.length > 0) {
+    let nestedState = state;
+    for (; route = routes.shift(); ) {
+      initialRoute = findInitialRoute(route.name, parentScreens, initialRoutes);
+      const nestedStateIndex = nestedState.index || nestedState.routes.length - 1;
+      nestedState.routes[nestedStateIndex].state = createStateObject(
+        route,
+        routes.length === 0,
+        initialRoute
+      ), routes.length > 0 && (nestedState = nestedState.routes[nestedStateIndex].state), parentScreens.push(route.name);
+    }
+  }
+  route = (0, import_findFocusedRoute.findFocusedRoute)(state), route.path = path;
+  const params = parseQueryParams(route.path, findParseConfigForRoute(route.name, routeConfigs));
+  if (params) {
+    route.params = Object.assign(/* @__PURE__ */ Object.create(null), route.params);
+    for (const [name, value] of Object.entries(params))
+      if (route.params?.[name] && process.env.NODE_ENV !== "production" && console.warn(
+        `Route '/${route.name}' with param '${name}' was specified both in the path and as a param, removing from path`
+      ), !route.params?.[name]) {
+        route.params[name] = value;
+        continue;
+      }
+    Object.keys(route.params).length === 0 && delete route.params;
+  }
+  return hash && (route.params = Object.assign(/* @__PURE__ */ Object.create(null), route.params), route.params["#"] = hash), state;
+}, parseQueryParams = (path, parseConfig) => {
+  const query = path.split("?")[1], searchParams = new URLSearchParams(query), params = Object.fromEntries(
+    // @ts-ignore: [Symbol.iterator] is indeed, available on every platform.
+    searchParams
+  );
+  return parseConfig && Object.keys(params).forEach((name) => {
+    Object.hasOwnProperty.call(parseConfig, name) && typeof params[name] == "string" && (params[name] = parseConfig[name](params[name]));
+  }), Object.keys(params).length ? params : void 0;
+}, baseUrlCache = /* @__PURE__ */ new Map();
+function getBaseUrlRegex(baseUrl) {
+  if (baseUrlCache.has(baseUrl))
+    return baseUrlCache.get(baseUrl);
+  const regex = new RegExp(`^\\/?${(0, import_escape_string_regexp.default)(baseUrl)}`, "g");
+  return baseUrlCache.set(baseUrl, regex), regex;
+}
+function stripBaseUrl(path, baseUrl = process.env.EXPO_BASE_URL) {
+  if (process.env.NODE_ENV !== "development" && baseUrl) {
+    const reg = getBaseUrlRegex(baseUrl);
+    return path.replace(/^\/+/g, "/").replace(reg, "");
+  }
+  return path;
+}
+//# sourceMappingURL=getStateFromPath.js.map

package/dist/cjs/fork/useLinking.js

@@ -0,0 +1,182 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var useLinking_exports = {};
+__export(useLinking_exports, {
+  default: () => useLinking,
+  series: () => series
+});
+module.exports = __toCommonJS(useLinking_exports);
+var import_core = require("@react-navigation/core"), import_fast_deep_equal = __toESM(require("fast-deep-equal"), 1), React = __toESM(require("react"), 1), import_createMemoryHistory = __toESM(require("./createMemoryHistory"), 1), import_serverLocationContext = require("../router/serverLocationContext"), import_getPathFromState = require("./getPathFromState");
+const historyGlobal = (0, import_createMemoryHistory.default)();
+typeof window < "u" && historyGlobal.listen(() => {
+  globalThis.__vxrntodopath = window.location.pathname;
+});
+const findMatchingState = (a, b) => {
+  if (a === void 0 || b === void 0 || a.key !== b.key)
+    return [void 0, void 0];
+  const aHistoryLength = a.history ? a.history.length : a.routes.length, bHistoryLength = b.history ? b.history.length : b.routes.length, aRoute = a.routes[a.index], bRoute = b.routes[b.index], aChildState = aRoute.state, bChildState = bRoute.state;
+  return aHistoryLength !== bHistoryLength || aRoute.key !== bRoute.key || aChildState === void 0 || bChildState === void 0 || aChildState.key !== bChildState.key ? [a, b] : findMatchingState(aChildState, bChildState);
+}, series = (cb) => {
+  let queue = Promise.resolve();
+  return () => {
+    queue = queue.then(cb);
+  };
+};
+let linkingHandlers = [];
+function useLinking(ref, {
+  independent,
+  enabled = !0,
+  config,
+  getStateFromPath = import_core.getStateFromPath,
+  getPathFromState = import_core.getPathFromState,
+  getActionFromState = import_core.getActionFromState
+}) {
+  React.useEffect(() => {
+    if (process.env.NODE_ENV === "production" || independent)
+      return;
+    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"
+      ].join(`
+`).trim()
+    );
+    const handler = Symbol();
+    return enabled !== !1 && linkingHandlers.push(handler), () => {
+      const index = linkingHandlers.indexOf(handler);
+      index > -1 && linkingHandlers.splice(index, 1);
+    };
+  }, [enabled, independent]);
+  const [history] = React.useState(historyGlobal), enabledRef = React.useRef(enabled), configRef = React.useRef(config), getStateFromPathRef = React.useRef(getStateFromPath), getPathFromStateRef = React.useRef(getPathFromState), getActionFromStateRef = React.useRef(getActionFromState);
+  React.useEffect(() => {
+    enabledRef.current = enabled, configRef.current = config, getStateFromPathRef.current = getStateFromPath, getPathFromStateRef.current = getPathFromState, getActionFromStateRef.current = getActionFromState;
+  });
+  const server = { location: React.useContext(import_serverLocationContext.ServerLocationContext) }, getInitialState = React.useCallback(() => {
+    let value;
+    if (enabledRef.current) {
+      const location2 = server?.location ?? (typeof window < "u" ? window.location : void 0), path = location2 ? location2.pathname + location2.search : void 0;
+      path && (value = getStateFromPathRef.current(path, configRef.current));
+    }
+    const thenable = {
+      // biome-ignore lint/suspicious/noThenProperty: <explanation>
+      then(onfulfilled) {
+        return Promise.resolve(onfulfilled ? onfulfilled(value) : value);
+      },
+      catch() {
+        return thenable;
+      }
+    };
+    return thenable;
+  }, []), previousIndexRef = React.useRef(void 0), previousStateRef = React.useRef(void 0), pendingPopStatePathRef = React.useRef(void 0);
+  return React.useEffect(() => (previousIndexRef.current = history.index, history.listen(() => {
+    const navigation = ref.current;
+    if (!navigation || !enabled)
+      return;
+    const { location: location2 } = window, path = location2.pathname + location2.search, index = history.index, previousIndex = previousIndexRef.current ?? 0;
+    previousIndexRef.current = index, pendingPopStatePathRef.current = path;
+    const record = history.get(index);
+    if (record?.path === path && record?.state) {
+      navigation.resetRoot(record.state);
+      return;
+    }
+    const state = getStateFromPathRef.current(path, configRef.current);
+    if (state) {
+      const rootState = navigation.getRootState();
+      if (state.routes.some((r) => !rootState?.routeNames.includes(r.name))) {
+        console.warn(
+          "The navigation state parsed from the URL contains routes not present in the root navigator. This usually means that the linking configuration doesn't match the navigation structure. See https://reactnavigation.org/docs/configuring-links for more details on how to specify a linking configuration."
+        );
+        return;
+      }
+      if (index > previousIndex) {
+        const 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 '${path}': ${typeof e == "object" && e != null && "message" in e ? e.message : e}`
+            );
+          }
+        else
+          navigation.resetRoot(state);
+      } else
+        navigation.resetRoot(state);
+    } else
+      navigation.resetRoot(state);
+  })), [enabled, history, ref]), React.useEffect(() => {
+    if (!enabled)
+      return;
+    const getPathForRoute = (route, state) => {
+      if (route?.path) {
+        const stateForPath = getStateFromPathRef.current(route.path, configRef.current);
+        if (stateForPath) {
+          const focusedRoute = (0, import_core.findFocusedRoute)(stateForPath);
+          if (focusedRoute && focusedRoute.name === route.name && (0, import_fast_deep_equal.default)(focusedRoute.params, route.params))
+            return (0, import_getPathFromState.appendBaseUrl)(route.path);
+        }
+      }
+      return getPathFromStateRef.current(state, configRef.current);
+    };
+    if (ref.current) {
+      const state = ref.current.getRootState();
+      if (state) {
+        const route = (0, import_core.findFocusedRoute)(state), path = getPathForRoute(route, state);
+        previousStateRef.current === void 0 && (previousStateRef.current = state), history.replace({ path, state });
+      }
+    }
+    const onStateChange = async () => {
+      const navigation = ref.current;
+      if (!navigation || !enabled)
+        return;
+      const previousState = previousStateRef.current, state = navigation.getRootState();
+      if (!state)
+        return;
+      const pendingPath = pendingPopStatePathRef.current, route = (0, import_core.findFocusedRoute)(state), path = getPathForRoute(route, state);
+      previousStateRef.current = state, pendingPopStatePathRef.current = void 0;
+      const [previousFocusedState, focusedState] = findMatchingState(previousState, state);
+      if (previousFocusedState && focusedState && // We should only handle push/pop if path changed from what was in last `popstate`
+      // Otherwise it's likely a change triggered by `popstate`
+      path !== pendingPath) {
+        const historyDelta = (focusedState.history ? focusedState.history.length : focusedState.routes.length) - (previousFocusedState.history ? previousFocusedState.history.length : previousFocusedState.routes.length);
+        if (historyDelta > 0)
+          history.push({ path, state });
+        else if (historyDelta < 0) {
+          const nextIndex = history.backIndex({ path }), currentIndex = history.index;
+          try {
+            nextIndex !== -1 && nextIndex < currentIndex && // We should only go back if the entry exists and it's less than current index
+            history.get(nextIndex - currentIndex) ? await history.go(nextIndex - currentIndex) : await history.go(historyDelta), history.replace({ path, state });
+          } catch {
+          }
+        } else
+          history.replace({ path, state });
+      } else
+        history.replace({ path, state });
+    };
+    return ref.current?.addListener("state", series(onStateChange));
+  }, [enabled, history, ref]), {
+    getInitialState
+  };
+}
+//# sourceMappingURL=useLinking.js.map

package/dist/cjs/fork/validatePathConfig.js

@@ -0,0 +1,46 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var validatePathConfig_exports = {};
+__export(validatePathConfig_exports, {
+  default: () => validatePathConfig
+});
+module.exports = __toCommonJS(validatePathConfig_exports);
+const formatToList = (items) => items.map((key) => `- ${key}`).join(`
+`);
+function validatePathConfig(config, root = !0) {
+  const validKeys = ["initialRouteName", "screens", "_route"];
+  root || validKeys.push("path", "exact", "stringify", "parse");
+  const invalidKeys = Object.keys(config).filter((key) => !validKeys.includes(key));
+  if (invalidKeys.length)
+    throw new Error(
+      `Found invalid properties in the configuration:
+${formatToList(
+        invalidKeys
+      )}
+
+Did you forget to specify them under a 'screens' property?
+
+You can only specify the following properties:
+${formatToList(
+        validKeys
+      )}
+
+See https://reactnavigation.org/docs/configuring-links for more details on how to specify a linking configuration.`
+    );
+  config.screens && Object.entries(config.screens).forEach(([_, value]) => {
+    typeof value != "string" && validatePathConfig(value, !1);
+  });
+}
+//# sourceMappingURL=validatePathConfig.js.map

package/dist/cjs/getLinkingConfig.js

@@ -0,0 +1,59 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var getLinkingConfig_exports = {};
+__export(getLinkingConfig_exports, {
+  getLinkingConfig: () => getLinkingConfig,
+  getNavigationConfig: () => getNavigationConfig,
+  stateCache: () => stateCache
+});
+module.exports = __toCommonJS(getLinkingConfig_exports);
+var import_native = require("@react-navigation/native"), import_getReactNavigationConfig = require("./getReactNavigationConfig"), import_linking = require("./link/linking");
+function getNavigationConfig(routes, metaOnly = !0) {
+  return (0, import_getReactNavigationConfig.getReactNavigationConfig)(routes, metaOnly);
+}
+function getLinkingConfig(routes, metaOnly = !0) {
+  return {
+    prefixes: [],
+    // @ts-expect-error
+    config: getNavigationConfig(routes, metaOnly),
+    // A custom getInitialURL is used on native to ensure the app always starts at
+    // the root path if it's launched from something other than a deep link.
+    // This helps keep the native functionality working like the web functionality.
+    // For example, if you had a root navigator where the first screen was `/settings` and the second was `/index`
+    // then `/index` would be used on web and `/settings` would be used on native.
+    getInitialURL: import_linking.getInitialURL,
+    subscribe: import_linking.addEventListener,
+    getStateFromPath: getStateFromPathMemoized,
+    getPathFromState(state, options) {
+      return (0, import_linking.getPathFromState)(state, {
+        screens: [],
+        ...this.config,
+        ...options
+      }) ?? "/";
+    },
+    // Add all functions to ensure the types never need to fallback.
+    // This is a convenience for usage in the package.
+    getActionFromState: import_native.getActionFromState
+  };
+}
+const stateCache = /* @__PURE__ */ new Map();
+function getStateFromPathMemoized(path, options) {
+  const cached = stateCache.get(path);
+  if (cached)
+    return cached;
+  const result = (0, import_linking.getStateFromPath)(path, options);
+  return stateCache.set(path, result), result;
+}
+//# sourceMappingURL=getLinkingConfig.js.map