decord/source/1607_useLinking.js

// Module ID: 1607
// Function ID: 1608
// Name: useLinking
// Dependencies: [19, 17, 1502, 1608]
// Exports: useLinking

// Module 1607 (useLinking)
import noop from "noop";
import get_ActivityIndicator from "get ActivityIndicator";

let Platform;
let c3;
const require = arg1;
({ Linking: c3, Platform } = get_ActivityIndicator);

export const useLinking = function useLinking(ref, enabled) {
  const _require = ref;
  let flag = enabled.enabled;
  if (flag === undefined) {
    flag = true;
  }
  const prefixes = enabled.prefixes;
  let filter = enabled.filter;
  const config = enabled.config;
  let fn = enabled.getInitialURL;
  if (fn === undefined) {
    fn = function f() {
      const items = [
        filter.getInitialURL(),
        new Promise((arg0) => {
          const timerId = setTimeout(arg0, 150);
        })
      ];
      return Promise.race(items);
    };
  }
  let fn2 = enabled.subscribe;
  if (fn2 === undefined) {
    fn2 = function l(arg0) {
      let closure_0 = arg0;
      function callback(url) {
        return callback(url.url);
      }
      let noop = filter.addEventListener("url", callback);
      const removeEventListener = filter.removeEventListener;
      let bindResult;
      if (removeEventListener != null) {
        bindResult = removeEventListener.bind(filter);
      }
      filter = bindResult;
      return () => {
        let remove;
        if (noop != null) {
          remove = obj.remove;
        }
        if (remove) {
          obj.remove();
        } else if (closure_3 != null) {
          tmp2("url", callback);
        }
      };
    };
  }
  let getStateFromPath = enabled.getStateFromPath;
  if (getStateFromPath === undefined) {
    getStateFromPath = _require(flag[2]).getStateFromPath;
  }
  let getActionFromState = enabled.getActionFromState;
  if (getActionFromState === undefined) {
    getActionFromState = _require(flag[2]).getActionFromState;
  }
  let closure_9;
  let closure_10;
  let closure_11;
  let closure_12;
  let closure_13;
  let closure_14;
  let closure_15;
  let callback;
  let items = [flag, _require(flag[2]).useNavigationIndependentTree()];
  const effect = prefixes.useEffect(() => {

  }, items);
  closure_9 = prefixes.useRef(flag);
  closure_10 = prefixes.useRef(prefixes);
  closure_11 = prefixes.useRef(filter);
  closure_12 = prefixes.useRef(config);
  closure_13 = prefixes.useRef(fn);
  closure_14 = prefixes.useRef(getStateFromPath);
  closure_15 = prefixes.useRef(getActionFromState);
  const effect1 = prefixes.useEffect(() => {
    closure_9.current = flag;
    closure_10.current = prefixes;
    closure_11.current = filter;
    closure_12.current = config;
    closure_13.current = fn;
    closure_14.current = getStateFromPath;
    closure_15.current = getActionFromState;
  });
  callback = prefixes.useCallback((AUTO_DISMISS) => {
    if (AUTO_DISMISS) {
      if (!ref3.current) {
        const extractPathFromURLResult = callback(flag[3]).extractPathFromURL(ref2.current, AUTO_DISMISS);
        if (undefined !== extractPathFromURLResult) {
          try {
            return ref6.current(extractPathFromURLResult, ref4.current);
          } catch (tmp7) {
            const _console = console;
            console.error(tmp7);
          }
        }
        const obj2 = callback(flag[3]);
      }
      const obj = ref3;
    }
  }, []);
  const items1 = [callback];
  const items2 = [flag, callback, ref, fn2];
  const getInitialState = prefixes.useCallback(() => {
    if (ref.current) {
      const currentResult = ref5.current();
      if (null != currentResult) {
        if (typeof currentResult !== "string") {
          return currentResult.then((arg0) => callback(arg0));
        }
      }
      let closure_0 = callback(currentResult);
    }
    const obj = {
      then(arg0) {
        if (arg0) {
          let tmp2 = arg0(tmp);
        } else {
          tmp2 = tmp;
        }
        return Promise.resolve(tmp2);
      },
      catch() {
        return obj;
      }
    };
    return obj;
  }, items1);
  const effect2 = prefixes.useEffect(() => fn2((arg0) => {
    if (closure_1) {
      const current = ref.current;
      if (current) {
        const tmp4 = callback(arg0);
      }
      if (current) {
        if (tmp4) {
          const currentResult = ref3.current(tmp4, ref2.current);
          if (undefined !== currentResult) {
            try {
              current.dispatch(currentResult);
            } catch (tmp11) {
              let message = tmp11;
              if (typeof tmp11 === "object") {
                message = tmp11;
                if (null != tmp11) {
                  message = tmp11;
                  if ("message" in tmp11) {
                    message = tmp11.message;
                  }
                }
              }
              const _HermesInternal = HermesInternal;
              console.warn("An error occurred when trying to handle the link '" + tmp + "': " + message);
            }
          } else {
            current.resetRoot(tmp4);
          }
        }
      }
    }
  }), items2);
  return { getInitialState };
};