{"version":3,"sources":["useLinking.tsx"],"names":["React","getStateFromPath","getStateFromPathDefault","getPathFromState","getPathFromStateDefault","getActionFromState","nanoid","ServerContext","createMemoryHistory","index","items","pending","interrupt","forEach","it","cb","history","id","window","state","findIndex","item","get","backIndex","path","i","push","slice","length","pushState","replace","replaceState","go","n","Math","min","Promise","resolve","reject","done","interrupted","clearTimeout","timer","Error","title","document","ref","setTimeout","splice","onPopState","last","pop","removeEventListener","addEventListener","listen","listener","findMatchingState","a","b","undefined","key","aHistoryLength","routes","bHistoryLength","aRoute","bRoute","aChildState","bChildState","series","handling","queue","callback","unshift","isUsingLinking","useLinking","enabled","config","useEffect","join","trim","useState","enabledRef","useRef","configRef","getStateFromPathRef","getPathFromStateRef","current","server","useContext","getInitialState","useCallback","value","location","pathname","search","thenable","then","onfulfilled","catch","previousIndexRef","previousStateRef","pendingPopStatePathRef","navigation","previousIndex","record","resetRoot","rootState","getRootState","some","r","routeNames","includes","name","console","warn","action","dispatch","e","message","onStateChange","previousState","pendingPath","previousFocusedState","focusedState","historyDelta","nextIndex","currentIndex","addListener"],"mappings":"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","sourcesContent":["import * as React from 'react';\nimport {\n  getStateFromPath as getStateFromPathDefault,\n  getPathFromState as getPathFromStateDefault,\n  NavigationContainerRef,\n  NavigationState,\n  getActionFromState,\n} from '@react-navigation/core';\nimport { nanoid } from 'nanoid/non-secure';\nimport ServerContext from './ServerContext';\nimport type { LinkingOptions } from './types';\n\ntype ResultState = ReturnType<typeof getStateFromPathDefault>;\n\ntype HistoryRecord = {\n  // Unique identifier for this record to match it with window.history.state\n  id: string;\n  // Navigation state object for the history entry\n  state: NavigationState;\n  // Path of the history entry\n  path: string;\n};\n\nconst createMemoryHistory = () => {\n  let index = 0;\n  let items: HistoryRecord[] = [];\n\n  // Pending callbacks for `history.go(n)`\n  // We might modify the callback stored if it was interrupted, so we have a ref to identify it\n  const pending: { ref: unknown; cb: (interrupted?: boolean) => void }[] = [];\n\n  const interrupt = () => {\n    // If another history operation was performed we need to interrupt existing ones\n    // This makes sure that calls such as `history.replace` after `history.go` don't happen\n    // Since otherwise it won't be correct if something else has changed\n    pending.forEach((it) => {\n      const cb = it.cb;\n      it.cb = () => cb(true);\n    });\n  };\n\n  const history = {\n    get index(): number {\n      // We store an id in the state instead of an index\n      // Index could get out of sync with in-memory values if page reloads\n      const id = window.history.state?.id;\n\n      if (id) {\n        const index = items.findIndex((item) => item.id === id);\n\n        return index > -1 ? index : 0;\n      }\n\n      return 0;\n    },\n\n    get(index: number) {\n      return items[index];\n    },\n\n    backIndex({ path }: { path: string }) {\n      // We need to find the index from the element before current to get closest path to go back to\n      for (let i = index - 1; i >= 0; i--) {\n        const item = items[i];\n\n        if (item.path === path) {\n          return i;\n        }\n      }\n\n      return -1;\n    },\n\n    push({ path, state }: { path: string; state: NavigationState }) {\n      interrupt();\n\n      const id = nanoid();\n\n      // When a new entry is pushed, all the existing entries after index will be inaccessible\n      // So we remove any existing entries after the current index to clean them up\n      items = items.slice(0, index + 1);\n\n      items.push({ path, state, id });\n      index = items.length - 1;\n\n      // We pass empty string for title because it's ignored in all browsers except safari\n      // We don't store state object in history.state because:\n      // - browsers have limits on how big it can be, and we don't control the size\n      // - while not recommended, there could be non-serializable data in state\n      window.history.pushState({ id }, '', path);\n    },\n\n    replace({ path, state }: { path: string; state: NavigationState }) {\n      interrupt();\n\n      const id = window.history.state?.id ?? nanoid();\n\n      if (items.length) {\n        items[index] = { path, state, id };\n      } else {\n        // This is the first time any state modifications are done\n        // So we need to push the entry as there's nothing to replace\n        items.push({ path, state, id });\n      }\n\n      window.history.replaceState({ id }, '', path);\n    },\n\n    // `history.go(n)` is asynchronous, there are couple of things to keep in mind:\n    // - it won't do anything if we can't go `n` steps, the `popstate` event won't fire.\n    // - each `history.go(n)` call will trigger a separate `popstate` event with correct location.\n    // - the `popstate` event fires before the next frame after calling `history.go(n)`.\n    // This method differs from `history.go(n)` in the sense that it'll go back as many steps it can.\n    go(n: number) {\n      interrupt();\n\n      if (n > 0) {\n        // We shouldn't go forward more than available index\n        n = Math.min(n, items.length - 1);\n      } else if (n < 0) {\n        // We shouldn't go back more than the 0 index\n        // Otherwise we'll exit the page\n        n = index + n < 0 ? -index : n;\n      }\n\n      if (n === 0) {\n        return;\n      }\n\n      index += n;\n\n      // When we call `history.go`, `popstate` will fire when there's history to go back to\n      // So we need to somehow handle following cases:\n      // - There's history to go back, `history.go` is called, and `popstate` fires\n      // - `history.go` is called multiple times, we need to resolve on respective `popstate`\n      // - No history to go back, but `history.go` was called, browser has no API to detect it\n      return new Promise((resolve, reject) => {\n        const done = (interrupted?: boolean) => {\n          clearTimeout(timer);\n\n          if (interrupted) {\n            reject(new Error('History was changed during navigation.'));\n            return;\n          }\n\n          // There seems to be a bug in Chrome regarding updating the title\n          // If we set a title just before calling `history.go`, the title gets lost\n          // However the value of `document.title` is still what we set it to\n          // It's just not displayed in the tab bar\n          // To update the tab bar, we need to reset the title to something else first (e.g. '')\n          // And set the title to what it was before so it gets applied\n          // It won't work without setting it to empty string coz otherwise title isn't changing\n          // Which means that the browser won't do anything after setting the title\n          const { title } = window.document;\n\n          window.document.title = '';\n          window.document.title = title;\n\n          resolve();\n        };\n\n        pending.push({ ref: done, cb: done });\n\n        // If navigation didn't happen within 100ms, assume that it won't happen\n        // This may not be accurate, but hopefully it won't take so much time\n        // In Chrome, navigation seems to happen instantly in next microtask\n        // But on Firefox, it seems to take much longer, around 50ms from our testing\n        // We're using a hacky timeout since there doesn't seem to be way to know for sure\n        const timer = setTimeout(() => {\n          const index = pending.findIndex((it) => it.ref === done);\n\n          if (index > -1) {\n            pending[index].cb();\n            pending.splice(index, 1);\n          }\n        }, 100);\n\n        const onPopState = () => {\n          const last = pending.pop();\n\n          window.removeEventListener('popstate', onPopState);\n          last?.cb();\n        };\n\n        window.addEventListener('popstate', onPopState);\n        window.history.go(n);\n      });\n    },\n\n    // The `popstate` event is triggered when history changes, except `pushState` and `replaceState`\n    // If we call `history.go(n)` ourselves, we don't want it to trigger the listener\n    // Here we normalize it so that only external changes (e.g. user pressing back/forward) trigger the listener\n    listen(listener: () => void) {\n      const onPopState = () => {\n        if (pending.length) {\n          // This was triggered by `history.go(n)`, we shouldn't call the listener\n          return;\n        }\n\n        listener();\n      };\n\n      window.addEventListener('popstate', onPopState);\n\n      return () => window.removeEventListener('popstate', onPopState);\n    },\n  };\n\n  return history;\n};\n\n/**\n * Find the matching navigation state that changed between 2 navigation states\n * e.g.: a -> b -> c -> d and a -> b -> c -> e -> f, if history in b changed, b is the matching state\n */\nconst findMatchingState = <T extends NavigationState>(\n  a: T | undefined,\n  b: T | undefined\n): [T | undefined, T | undefined] => {\n  if (a === undefined || b === undefined || a.key !== b.key) {\n    return [undefined, undefined];\n  }\n\n  // Tab and drawer will have `history` property, but stack will have history in `routes`\n  const aHistoryLength = a.history ? a.history.length : a.routes.length;\n  const bHistoryLength = b.history ? b.history.length : b.routes.length;\n\n  const aRoute = a.routes[a.index];\n  const bRoute = b.routes[b.index];\n\n  const aChildState = aRoute.state as T | undefined;\n  const bChildState = bRoute.state as T | undefined;\n\n  // Stop here if this is the state object that changed:\n  // - history length is different\n  // - focused routes are different\n  // - one of them doesn't have child state\n  // - child state keys are different\n  if (\n    aHistoryLength !== bHistoryLength ||\n    aRoute.key !== bRoute.key ||\n    aChildState === undefined ||\n    bChildState === undefined ||\n    aChildState.key !== bChildState.key\n  ) {\n    return [a, b];\n  }\n\n  return findMatchingState(aChildState, bChildState);\n};\n\n/**\n * Run async function in series as it's called.\n */\nconst series = (cb: () => Promise<void>) => {\n  // Whether we're currently handling a callback\n  let handling = false;\n  let queue: (() => Promise<void>)[] = [];\n\n  const callback = async () => {\n    try {\n      if (handling) {\n        // If we're currently handling a previous event, wait before handling this one\n        // Add the callback to the beginning of the queue\n        queue.unshift(callback);\n        return;\n      }\n\n      handling = true;\n\n      await cb();\n    } finally {\n      handling = false;\n\n      if (queue.length) {\n        // If we have queued items, handle the last one\n        const last = queue.pop();\n\n        last?.();\n      }\n    }\n  };\n\n  return callback;\n};\n\nlet isUsingLinking = false;\n\nexport default function useLinking(\n  ref: React.RefObject<NavigationContainerRef>,\n  {\n    enabled = true,\n    config,\n    getStateFromPath = getStateFromPathDefault,\n    getPathFromState = getPathFromStateDefault,\n  }: LinkingOptions\n) {\n  React.useEffect(() => {\n    if (enabled !== false && isUsingLinking) {\n      throw new Error(\n        [\n          'Looks like you have configured linking in multiple places. This is likely an error since URL integration should only be handled in one place to avoid conflicts. Make sure that:',\n          \"- You are not using both 'linking' prop and 'useLinking'\",\n          \"- You don't have 'useLinking' in multiple components\",\n        ]\n          .join('\\n')\n          .trim()\n      );\n    } else {\n      isUsingLinking = enabled !== false;\n    }\n\n    return () => {\n      isUsingLinking = false;\n    };\n  });\n\n  const [history] = React.useState(createMemoryHistory);\n\n  // We store these options in ref to avoid re-creating getInitialState and re-subscribing listeners\n  // This lets user avoid wrapping the items in `React.useCallback` or `React.useMemo`\n  // Not re-creating `getInitialState` is important coz it makes it easier for the user to use in an effect\n  const enabledRef = React.useRef(enabled);\n  const configRef = React.useRef(config);\n  const getStateFromPathRef = React.useRef(getStateFromPath);\n  const getPathFromStateRef = React.useRef(getPathFromState);\n\n  React.useEffect(() => {\n    enabledRef.current = enabled;\n    configRef.current = config;\n    getStateFromPathRef.current = getStateFromPath;\n    getPathFromStateRef.current = getPathFromState;\n  }, [config, enabled, getPathFromState, getStateFromPath]);\n\n  const server = React.useContext(ServerContext);\n\n  const getInitialState = React.useCallback(() => {\n    let value: ResultState | undefined;\n\n    if (enabledRef.current) {\n      const location =\n        server?.location ??\n        (typeof window !== 'undefined' ? window.location : undefined);\n\n      const path = location ? location.pathname + location.search : undefined;\n\n      if (path) {\n        value = getStateFromPathRef.current(path, configRef.current);\n      }\n    }\n\n    // Make it a thenable to keep consistent with the native impl\n    const thenable = {\n      then(onfulfilled?: (state: ResultState | undefined) => void) {\n        return Promise.resolve(onfulfilled ? onfulfilled(value) : value);\n      },\n      catch() {\n        return thenable;\n      },\n    };\n\n    return thenable as PromiseLike<ResultState | undefined>;\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, []);\n\n  const previousIndexRef = React.useRef<number | undefined>(undefined);\n  const previousStateRef = React.useRef<NavigationState | undefined>(undefined);\n  const pendingPopStatePathRef = React.useRef<string | undefined>(undefined);\n\n  React.useEffect(() => {\n    previousIndexRef.current = history.index;\n\n    return history.listen(() => {\n      const navigation = ref.current;\n\n      if (!navigation || !enabled) {\n        return;\n      }\n\n      const path = location.pathname + location.search;\n      const index = history.index;\n\n      const previousIndex = previousIndexRef.current ?? 0;\n\n      previousIndexRef.current = index;\n      pendingPopStatePathRef.current = path;\n\n      // When browser back/forward is clicked, we first need to check if state object for this index exists\n      // If it does we'll reset to that state object\n      // Otherwise, we'll handle it like a regular deep link\n      const record = history.get(index);\n\n      if (record?.path === path && record?.state) {\n        navigation.resetRoot(record.state);\n        return;\n      }\n\n      const state = getStateFromPathRef.current(path, configRef.current);\n\n      // We should only dispatch an action when going forward\n      // Otherwise the action will likely add items to history, which would mess things up\n      if (state) {\n        // Make sure that the routes in the state exist in the root navigator\n        // Otherwise there's an error in the linking configuration\n        const rootState = navigation.getRootState();\n\n        if (state.routes.some((r) => !rootState?.routeNames.includes(r.name))) {\n          console.warn(\n            \"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.\"\n          );\n          return;\n        }\n\n        if (index > previousIndex) {\n          const action = getActionFromState(state, configRef.current);\n\n          if (action !== undefined) {\n            try {\n              navigation.dispatch(action);\n            } catch (e) {\n              // Ignore any errors from deep linking.\n              // This could happen in case of malformed links, navigation object not being initialized etc.\n              console.warn(\n                `An error occurred when trying to handle the link '${path}': ${e.message}`\n              );\n            }\n          } else {\n            navigation.resetRoot(state);\n          }\n        } else {\n          navigation.resetRoot(state);\n        }\n      } else {\n        // if current path didn't return any state, we should revert to initial state\n        navigation.resetRoot(state);\n      }\n    });\n  }, [enabled, history, ref]);\n\n  React.useEffect(() => {\n    if (!enabled) {\n      return;\n    }\n\n    if (ref.current) {\n      // We need to record the current metadata on the first render if they aren't set\n      // This will allow the initial state to be in the history entry\n      const state = ref.current.getRootState();\n\n      if (state) {\n        const path = getPathFromStateRef.current(state, configRef.current);\n\n        if (previousStateRef.current === undefined) {\n          previousStateRef.current = state;\n        }\n\n        history.replace({ path, state });\n      }\n    }\n\n    const onStateChange = async () => {\n      const navigation = ref.current;\n\n      if (!navigation || !enabled) {\n        return;\n      }\n\n      const previousState = previousStateRef.current;\n      const state = navigation.getRootState();\n\n      const pendingPath = pendingPopStatePathRef.current;\n      const path = getPathFromStateRef.current(state, configRef.current);\n\n      previousStateRef.current = state;\n      pendingPopStatePathRef.current = undefined;\n\n      // To detect the kind of state change, we need to:\n      // - Find the common focused navigation state in previous and current state\n      // - If only the route keys changed, compare history/routes.length to check if we go back/forward/replace\n      // - If no common focused navigation state found, it's a replace\n      const [previousFocusedState, focusedState] = findMatchingState(\n        previousState,\n        state\n      );\n\n      if (\n        previousFocusedState &&\n        focusedState &&\n        // We should only handle push/pop if path changed from what was in last `popstate`\n        // Otherwise it's likely a change triggered by `popstate`\n        path !== pendingPath\n      ) {\n        const historyDelta =\n          (focusedState.history\n            ? focusedState.history.length\n            : focusedState.routes.length) -\n          (previousFocusedState.history\n            ? previousFocusedState.history.length\n            : previousFocusedState.routes.length);\n\n        if (historyDelta > 0) {\n          // If history length is increased, we should pushState\n          // Note that path might not actually change here, for example, drawer open should pushState\n          history.push({ path, state });\n        } else if (historyDelta < 0) {\n          // If history length is decreased, i.e. entries were removed, we want to go back\n\n          const nextIndex = history.backIndex({ path });\n          const currentIndex = history.index;\n\n          try {\n            if (nextIndex !== -1 && nextIndex < currentIndex) {\n              // An existing entry for this path exists and it's less than current index, go back to that\n              await history.go(nextIndex - currentIndex);\n            } else {\n              // We couldn't find an existing entry to go back to, so we'll go back by the delta\n              // This won't be correct if multiple routes were pushed in one go before\n              // Usually this shouldn't happen and this is a fallback for that\n              await history.go(historyDelta);\n            }\n\n            // Store the updated state as well as fix the path if incorrect\n            history.replace({ path, state });\n          } catch (e) {\n            // The navigation was interrupted\n          }\n        } else {\n          // If history length is unchanged, we want to replaceState\n          history.replace({ path, state });\n        }\n      } else {\n        // If no common navigation state was found, assume it's a replace\n        // This would happen if the user did a reset/conditionally changed navigators\n        history.replace({ path, state });\n      }\n    };\n\n    // We debounce onStateChange coz we don't want multiple state changes to be handled at one time\n    // This could happen since `history.go(n)` is asynchronous\n    // If `pushState` or `replaceState` were called before `history.go(n)` completes, it'll mess stuff up\n    return ref.current?.addListener('state', series(onStateChange));\n  });\n\n  return {\n    getInitialState,\n  };\n}\n"]}