decord/source/1510_isValidKey.js

// Module ID: 1510
// Function ID: 17365
// Name: isValidKey
// Dependencies: [57, 77, 29, 65, 31, 33, 1460, 1487, 1486, 1511, 1483, 1470, 1512, 1513, 1461, 1480, 1476, 1514, 1472, 1473, 1515, 1517, 1518, 1519, 1520, 1521, 1525, 1526, 1502, 1504]
// Exports: default

// Module 1510 (isValidKey)
import _slicedToArray from "_slicedToArray";
import _defineProperty from "_defineProperty";
import transformPreventedRoutes from "transformPreventedRoutes";
import _toConsumableArray from "_toConsumableArray";
import result from "result";
import { jsx } from "jsxProd";
import { PrivateValueStore } from "PrivateValueStore";

const require = arg1;
let closure_3 = ["children", "screenListeners"];
function isValidKey(arg0) {
  let tmp = undefined === arg0;
  if (!tmp) {
    let tmp2 = "string" === typeof arg0;
    if (tmp2) {
      tmp2 = "" !== arg0;
    }
    tmp = tmp2;
  }
  return tmp;
}
function getRouteConfigsFromChildren(arg0, arg1, arg2) {
  let closure_0 = arg1;
  let closure_1 = arg2;
  const Children = React.Children;
  return Children.toArray(arg0).reduce((arr, type) => {
    if (outer1_8.isValidElement(type)) {
      if (type.type === callback(outer1_2[7])) {
        if (outer1_10(type.props.navigationKey)) {
          const obj = {};
          const items = [closure_0, type.props.navigationKey];
          obj.keys = items;
          obj.options = callback;
          obj.props = type.props;
          arr.push(obj);
          return arr;
        } else {
          const _Error2 = Error;
          const _JSON3 = JSON;
          const _HermesInternal5 = HermesInternal;
          const error = new Error("Got an invalid 'navigationKey' prop (" + JSON.stringify(type.props.navigationKey) + ") for the screen '" + type.props.name + "'. It must be a non-empty string or 'undefined'.");
          throw error;
        }
      } else if (outer1_10(type.props.navigationKey)) {
        const push = arr.push;
        if (type.type !== callback(outer1_2[8])) {
          let combined = callback;
        } else if (null != callback) {
          const items1 = [];
          const items2 = [type.props.screenOptions];
          combined = items1.concat(outer1_7(callback), items2);
        } else {
          combined = [type.props.screenOptions];
        }
        push.apply(arr, outer1_7(outer1_11(type.props.children, type.props.navigationKey, combined)));
        return arr;
      } else {
        const _Error = Error;
        const _JSON2 = JSON;
        const _HermesInternal4 = HermesInternal;
        const error1 = new Error("Got an invalid 'navigationKey' prop (" + JSON.stringify(type.props.navigationKey) + ") for the group. It must be a non-empty string or 'undefined'.");
        throw error1;
      }
    }
    if (outer1_8.isValidElement(type)) {
      if ("string" === typeof type.type) {
        let name = type.type;
      } else {
        type = type.type;
        if (null != type) {
          name = type.name;
        }
      }
      let str5 = "";
      if (null != type.props) {
        str5 = "";
        if ("object" === typeof type.props) {
          str5 = "";
          if ("name" in type.props) {
            const props = type.props;
            str5 = "";
            if (null != props) {
              str5 = "";
              if (props.name) {
                const _HermesInternal2 = HermesInternal;
                str5 = " for the screen '" + type.props.name + "'";
              }
            }
          }
        }
      }
      const _HermesInternal3 = HermesInternal;
      let combined1 = "'" + name + "'" + str5;
    } else if ("object" === typeof type) {
      const _JSON = JSON;
      combined1 = JSON.stringify(type);
    } else {
      const _String = String;
      const _HermesInternal = HermesInternal;
      combined1 = "'" + String(type) + "'";
    }
    const error2 = new Error("A navigator can only contain 'Screen', 'Group' or 'React.Fragment' as its direct children (found " + combined1 + "). To render this component in the navigator, pass it in the 'component' prop to 'Screen'.");
    throw error2;
  }, []);
}

export default function useNavigationBuilder(StackRouter, screenListeners) {
  let closure_13;
  let closure_14;
  let closure_15;
  const _require = context(screenListeners[9])();
  context = callback.useContext(context(screenListeners[10]));
  screenListeners = screenListeners.screenListeners;
  let tmp4 = null;
  if (null != context) {
    tmp4 = null;
    if (context.params) {
      tmp4 = null;
      if (null == context.params.state) {
        tmp4 = null;
        if (false !== context.params.initial) {
          tmp4 = null;
          if ("string" === typeof context.params.screen) {
            let obj = { initialRouteName: context.params.screen };
            tmp4 = obj;
          }
        }
      }
    }
  }
  current = callback.useRef(StackRouter(Object.assign({}, reduced1(screenListeners, current), tmp4))).current;
  const arr = getState(screenListeners.children);
  let reduced = arr.reduce((arg0, props) => {
    if (props.props.name in arg0) {
      const _Error = Error;
      const _HermesInternal = HermesInternal;
      const error = new Error("A navigator cannot contain multiple 'Screen' components with the same name (found duplicate screen named '" + props.props.name + "')");
      throw error;
    } else {
      arg0[props.props.name] = props;
      return arg0;
    }
  }, {});
  let mapped = arr.map((props) => props.props.name);
  reduced1 = mapped.reduce((arg0, arg1) => {
    const keys = reduced[arg1].keys;
    const mapped = keys.map((arg0) => {
      let str = "";
      if (null != arg0) {
        str = arg0;
      }
      return str;
    });
    arg0[arg1] = mapped.join(":");
    return arg0;
  }, {});
  const reduced2 = mapped.reduce((arg0, arg1) => {
    arg0[arg1] = reduced[arg1].props.initialParams;
    return arg0;
  }, {});
  const reduced3 = mapped.reduce((arg0, arg1) => Object.assign(arg0, mapped({}, arg1, reduced[arg1].props.getId)), {});
  if (mapped.length) {
    let items = [current.type];
    callback = callback.useCallback((type) => {
      let tmp = undefined === type.type;
      if (!tmp) {
        tmp = type.type === current.type;
      }
      return tmp;
    }, items);
    let items1 = [callback];
    const callback1 = callback.useCallback((stale) => {
      let tmp = undefined !== stale;
      if (tmp) {
        tmp = false === stale.stale;
      }
      if (tmp) {
        tmp = callback(stale);
      }
      return tmp;
    }, items1);
    const context1 = callback.useContext(context(screenListeners[11]));
    let state = context1.state;
    getState = context1.getState;
    const setState = context1.setState;
    ({ setKey: closure_13, getKey: closure_14, getIsInitial: closure_15 } = context1);
    let closure_16 = callback.useRef(false);
    let items2 = [setState];
    let closure_17 = callback.useCallback(() => {
      setState(undefined);
      closure_16.current = true;
    }, items2);
    const items3 = [setState];
    const callback2 = callback.useCallback((arg0) => {
      if (!ref.current) {
        setState(arg0);
      }
    }, items3);
    const items4 = [state, current, callback];
    const tmp21 = reduced(callback.useMemo(() => {
      const reduced = mapped.reduce((arg0, arg1) => {
        const initialParams = outer1_4[arg1].props.initialParams;
        let state;
        if (null != outer1_1) {
          const params = outer1_1.params;
          if (null != params) {
            state = params.state;
          }
        }
        if (null == state) {
          let initial;
          if (null != outer1_1) {
            const params3 = outer1_1.params;
            if (null != params3) {
              initial = params3.initial;
            }
          }
          if (false !== initial) {
            let screen;
            if (null != outer1_1) {
              const params4 = outer1_1.params;
              if (null != params4) {
                screen = params4.screen;
              }
            }
            if (screen === arg1) {
              const params2 = outer1_1.params.params;
            }
          }
        }
        if (undefined !== initialParams) {
          const _Object = Object;
          const merged = Object.assign({}, initialParams, params2);
        }
        arg0[arg1] = merged;
        return arg0;
      }, {});
      if (undefined === state) {
        state = undefined;
        if (null != context) {
          let params = context.params;
          if (null != params) {
            state = params.state;
          }
        }
        if (null == state) {
          let obj = { routeNames: mapped, routeParamList: reduced, routeGetIdList: reduced3 };
          let items = [current.getInitialState(obj), true];
        }
        return items;
      }
      let state1;
      if (null != context) {
        let params2 = context.params;
        if (null != params2) {
          state1 = params2.state;
        }
      }
      if (null == state1) {
        state1 = state;
      }
      obj = { routeNames: mapped, routeParamList: reduced, routeGetIdList: reduced3 };
      const items1 = [current.getRehydratedState(state1, obj), false];
      items = items1;
    }, items4), 2);
    const first = tmp21[0];
    const ref = callback.useRef(reduced1);
    const effect = callback.useEffect(() => {
      ref.current = reduced1;
    });
    const current2 = ref.current;
    let tmp25 = first;
    if (callback1(state)) {
      tmp25 = state;
    }
    let closure_21 = tmp25;
    let rehydratedState = tmp25;
    let tmp28 = context(screenListeners[12])(tmp25.routeNames, mapped);
    if (tmp28) {
      tmp28 = context(screenListeners[13])(reduced1, current2);
    }
    rehydratedState = tmp25;
    if (!tmp28) {
      obj = { routeNames: mapped, routeParamList: reduced2, routeGetIdList: reduced3 };
      let _Object = Object;
      let keys = Object.keys(reduced1);
      obj.routeKeyChanges = keys.filter((arg0) => {
        let hasOwnPropertyResult = current2.hasOwnProperty(arg0);
        if (hasOwnPropertyResult) {
          hasOwnPropertyResult = reduced1[arg0] !== current2[arg0];
        }
        return hasOwnPropertyResult;
      });
      const stateForRouteNamesChange = current.getStateForRouteNamesChange(tmp25, obj);
      rehydratedState = stateForRouteNamesChange;
      rehydratedState = stateForRouteNamesChange;
    }
    let params;
    if (null != context) {
      params = context.params;
    }
    const ref1 = callback.useRef(params);
    let params1;
    if (null != context) {
      params1 = context.params;
    }
    const items5 = [params1];
    const effect1 = callback.useEffect(() => {
      let params;
      if (null != context) {
        params = context.params;
      }
      ref1.current = params;
    }, items5);
    let tmp39 = rehydratedState;
    if (null != context) {
      tmp39 = rehydratedState;
      if (context.params) {
        const current3 = ref1.current;
        if ("object" === typeof context.params.state) {
          if (null != context.params.state) {
            if (context.params !== current3) {
              const CommonActions2 = _require(screenListeners[14]).CommonActions;
              let resetResult = CommonActions2.reset(context.params.state);
            }
            let stateForAction = null;
            if (resetResult) {
              obj = { routeNames: mapped, routeParamList: reduced2, routeGetIdList: reduced3 };
              stateForAction = current.getStateForAction(rehydratedState, resetResult, obj);
            }
            if (null !== stateForAction) {
              const obj1 = { routeNames: mapped, routeParamList: reduced2, routeGetIdList: reduced3 };
              rehydratedState = current.getRehydratedState(stateForAction, obj1);
            }
            tmp39 = rehydratedState;
          }
        }
        let tmp40 = "string" === typeof context.params.screen;
        if (tmp40) {
          tmp40 = false === context.params.initial && tmp21[1] || context.params !== current3;
          const tmp41 = false === context.params.initial && tmp21[1] || context.params !== current3;
        }
        if (tmp40) {
          const CommonActions = _require(screenListeners[14]).CommonActions;
          const obj2 = { name: context.params.screen, params: context.params.params, path: context.params.path };
          resetResult = CommonActions.navigate(obj2);
        }
      }
    }
    let closure_24 = tmp25 !== tmp39;
    context(screenListeners[15])(() => {
      if (closure_24) {
        callback2(rehydratedState);
      }
    });
    closure_21 = tmp39;
    const effect2 = callback.useEffect(() => {
      callback(closure_0);
      if (!callback2()) {
        callback2(rehydratedState);
      }
      return () => {
        const timerId = setTimeout(() => {
          let tmp = undefined !== outer2_11();
          if (tmp) {
            tmp = outer2_14() === outer2_0;
          }
          if (tmp) {
            outer2_17();
          }
        }, 0);
      };
    }, []);
    const ref2 = callback.useRef();
    ref2.current = first;
    const items6 = [getState, callback1];
    const callback3 = callback.useCallback(() => {
      let current = getState();
      if (!callback1(current)) {
        current = ref2.current;
      }
      return current;
    }, items6);
    const tmp55 = context(screenListeners[16])((target) => {
      let closure_0 = target;
      const items = [];
      const routes = tmp39.routes;
      if (target.target) {
        let found = routes.find((key) => key.key === target.target);
        let closure_1 = found;
        let tmp2 = found;
        if (tmp9) {
          items.push(found.name);
          tmp2 = found;
        }
        tmp9 = null != found && found.name;
      } else {
        closure_1 = routes[tmp39.index];
        const push = items.push;
        let _Object = Object;
        let keys = Object.keys(reduced);
        push.apply(items, reduced3(keys.filter((arg0) => {
          let name;
          if (null != name) {
            name = name.name;
          }
          return name === arg0;
        })));
      }
      if (null != tmp2) {
        const navigation = tmp73[tmp2.key].navigation;
        const items1 = [];
        const concat = items1.concat;
        const items2 = [navigation];
        const combined = items2.concat(reduced3(items.map((arg0) => outer1_4[arg0].props.listeners)));
        const found1 = concat.apply(items1, reduced3(combined.map((arg0) => {
          let tmp = arg0;
          if ("function" === typeof arg0) {
            const obj = { route: closure_1, navigation };
            tmp = arg0(obj);
          }
          let closure_0 = tmp;
          let mapped;
          if (tmp) {
            const _Object = Object;
            const keys = Object.keys(tmp);
            const found = keys.filter((arg0) => arg0 === tmp.type);
            mapped = found.map((arg0) => {
              let tmp;
              if (null != tmp) {
                tmp = tmp[arg0];
              }
              return tmp;
            });
          }
          return mapped;
        }))).filter((arg0, arg1, arr) => {
          let tmp = arg0;
          if (arg0) {
            tmp = arr.lastIndexOf(arg0) === arg1;
          }
          return tmp;
        });
        const item = found1.forEach((arg0) => {
          let tmp;
          if (null != arg0) {
            tmp = arg0(closure_0);
          }
          return tmp;
        });
        const applyResult1 = concat.apply(items1, reduced3(combined.map((arg0) => {
          let tmp = arg0;
          if ("function" === typeof arg0) {
            const obj = { route: closure_1, navigation };
            tmp = arg0(obj);
          }
          let closure_0 = tmp;
          let mapped;
          if (tmp) {
            const _Object = Object;
            const keys = Object.keys(tmp);
            const found = keys.filter((arg0) => arg0 === tmp.type);
            mapped = found.map((arg0) => {
              let tmp;
              if (null != tmp) {
                tmp = tmp[arg0];
              }
              return tmp;
            });
          }
          return mapped;
        })));
      }
    });
    let closure_26 = tmp55;
    const obj3 = { state: tmp39, emitter: tmp55 };
    context(screenListeners[17])(obj3);
    const items7 = [tmp55, tmp39];
    const effect3 = callback.useEffect(() => {
      tmp55.emit({ type: "state", data: { state: closure_21 } });
    }, items7);
    const tmp58 = context(screenListeners[18])();
    const listeners = tmp58.listeners;
    const tmp59 = context(screenListeners[19])();
    const keyedListeners = tmp59.keyedListeners;
    const obj4 = { router: current, getState: callback3, setState: callback2 };
    let key;
    if (null != context) {
      key = context.key;
    }
    obj4.key = key;
    obj4.actionListeners = listeners.action;
    obj4.beforeRemoveListeners = keyedListeners.beforeRemove;
    const obj5 = { routeNames: mapped, routeParamList: reduced2, routeGetIdList: reduced3 };
    obj4.routerConfigOptions = obj5;
    obj4.emitter = tmp55;
    const tmp60Result = context(screenListeners[20])(obj4);
    const obj6 = { router: current };
    let key1;
    const tmp60 = context(screenListeners[20]);
    if (null != context) {
      key1 = context.key;
    }
    obj6.key = key1;
    obj6.getState = callback3;
    obj6.setState = callback2;
    const tmp65 = context(screenListeners[21]);
    const obj7 = { id: screenListeners.id, onAction: tmp60Result, getState: callback3, emitter: tmp55, router: current };
    const tmp70 = context(screenListeners[22])(obj7);
    let closure_27 = tmp70;
    const obj8 = { navigation: tmp70, focusedListeners: listeners.focus };
    context(screenListeners[23])(obj8);
    const obj9 = { getState: callback3, getStateListeners: keyedListeners.getState };
    context(screenListeners[24])(obj9);
    const obj10 = { state: tmp39, screens: reduced, navigation: tmp70 };
    ({ screenOptions: obj13.screenOptions, defaultScreenOptions: obj13.defaultScreenOptions } = screenListeners);
    obj10.onAction = tmp60Result;
    obj10.getState = callback3;
    obj10.setState = callback2;
    obj10.onRouteFocus = context(screenListeners[21])(obj6);
    obj10.addListener = tmp58.addListener;
    obj10.addKeyedListener = tmp59.addKeyedListener;
    obj10.router = current;
    obj10.emitter = tmp55;
    const tmp73 = context(screenListeners[25])(obj10);
    let closure_28 = tmp73;
    const obj11 = { state: tmp39, navigation: tmp70, descriptors: tmp73 };
    context(screenListeners[26])(obj11);
    const obj12 = {
      state: tmp39,
      navigation: tmp70,
      descriptors: tmp73,
      NavigationContent: context(screenListeners[27])((children) => {
          let obj = { value: closure_27 };
          obj = { children };
          obj.children = callback1(context(screenListeners[29]), obj);
          return callback1(context(screenListeners[28]).Provider, obj);
        })
    };
    return obj12;
  } else {
    let _Error = Error;
    let error = new Error("Couldn't find any screens for the navigator. Have you defined any screens as its children?");
    throw error;
  }
  const tmp3 = reduced1(screenListeners, current);
};