da5b5e5efe
Skipped 1 file(s) >100MB (GitHub limit): source/__polyfill/04xxx/module_4821.js (118.4 MB)
523 lines
20 KiB
JavaScript
523 lines
20 KiB
JavaScript
// Module ID: 7107
|
|
// Function ID: 7108
|
|
// Dependencies: [109, 41, 42, 93, 95, 98, 19, 17, 21, 7108, 7111, 1484, 5712, 1614, 7115, 7117]
|
|
|
|
// Module 7107
|
|
import _objectWithoutProperties from "_objectWithoutProperties" /* 109 */;
|
|
import _classCallCheck from "_classCallCheck" /* 41 */;
|
|
import _createClass from "_createClass" /* 42 */;
|
|
import hasOwnProperty from "_possibleConstructorReturn" /* 93 */;
|
|
import _getPrototypeOf from "_getPrototypeOf" /* 95 */;
|
|
import _inherits from "_inherits" /* 98 */;
|
|
import noop from "module_19" /* 19 */;
|
|
|
|
let StackView = fn;
|
|
function _isNativeReflectConstruct() {
|
|
try {
|
|
const _Boolean = Boolean;
|
|
const call = valueOf.call;
|
|
const _Reflect = Reflect;
|
|
const _Boolean2 = Boolean;
|
|
if (typeof call === "unknown") {
|
|
let callResult = valueOf();
|
|
} else {
|
|
callResult = call(constructResult);
|
|
}
|
|
closure_0 = !callResult;
|
|
_isNativeReflectConstruct = function _isNativeReflectConstruct() {
|
|
return closure_0;
|
|
};
|
|
return _isNativeReflectConstruct();
|
|
} catch (err) {
|
|
}
|
|
}
|
|
let closure_2 = ["state", "descriptors"];
|
|
get_ActivityIndicator = fn(17);
|
|
({ StyleSheet, View } = get_ActivityIndicator);
|
|
const jsx = fn(21).jsx;
|
|
let GestureHandlerRootView = fn(7108).GestureHandlerRootView;
|
|
if (GestureHandlerRootView == null) {
|
|
GestureHandlerRootView = View;
|
|
}
|
|
function isArrayEqual(arg0, arg1) {
|
|
|
|
}
|
|
class StackView {
|
|
constructor() {
|
|
self = this;
|
|
items = [...arguments];
|
|
closure_0 = undefined;
|
|
tmp = closure_4(this, StackView);
|
|
items1 = [...items];
|
|
tmp2 = metroRequire;
|
|
obj = metroRequire(StackView);
|
|
tmp3 = hasOwnProperty;
|
|
if (closure_8()) {
|
|
tmp5 = globalThis;
|
|
_Reflect = Reflect;
|
|
constructResult = Reflect.construct(obj, items1, tmp2(self).constructor);
|
|
} else {
|
|
constructResult = obj.apply(self, items1);
|
|
}
|
|
tmp3Result = tmp3(self, constructResult);
|
|
closure_0 = tmp3Result;
|
|
obj1 = { routes: [], previousState: "y", openingRouteKeys: 0.5, closingRouteKeys: null, replacingRouteKeys: null, descriptors: null };
|
|
obj1.openingRouteKeys = [];
|
|
obj1.closingRouteKeys = [];
|
|
obj1.replacingRouteKeys = [];
|
|
obj1.descriptors = {};
|
|
tmp3Result.state = obj1;
|
|
tmp3Result.getPreviousRoute = (route) => {
|
|
route = route.route;
|
|
c1 = undefined;
|
|
c2 = undefined;
|
|
({ closingRouteKeys: c1, replacingRouteKeys: c2 } = closure_0.state);
|
|
const routes = closure_0.state.routes;
|
|
const found = routes.filter((key) => {
|
|
let tmp = key.key === route.key;
|
|
if (!tmp) {
|
|
const hasItem = _undefined.includes(key.key);
|
|
let tmp4 = !hasItem;
|
|
if (!hasItem) {
|
|
tmp4 = !_undefined2.includes(key.key);
|
|
}
|
|
tmp = tmp4;
|
|
}
|
|
return tmp;
|
|
});
|
|
return found[found.findIndex(found, (key) => key.key === route.key) - 1];
|
|
};
|
|
tmp3Result.renderHeader = (arg0) => {
|
|
const merged = Object.assign(arg0);
|
|
return jsx(closure_0(7111).HeaderContainer, {});
|
|
};
|
|
tmp3Result.handleOpenRoute = (route) => {
|
|
route = route.route;
|
|
({ state, navigation } = closure_0.props);
|
|
({ closingRouteKeys, replacingRouteKeys } = closure_0.state);
|
|
if (closingRouteKeys.some((item) => item === route.key)) {
|
|
if (replacingRouteKeys.every((item) => item !== route.key)) {
|
|
const routeNames = state.routeNames;
|
|
if (routeNames.includes(route.name)) {
|
|
let routes = state.routes;
|
|
if (!routes.some((key) => key.key === route.key)) {
|
|
navigation.dispatch((routes) => {
|
|
routes = routes.routes;
|
|
const items = [];
|
|
items[HermesBuiltin.arraySpread(routes.filter((key) => key.key !== key.key), 0)] = route;
|
|
const CommonActions = key(1484).CommonActions;
|
|
const obj = {};
|
|
const merged = Object.assign(routes);
|
|
obj.routes = items;
|
|
obj.index = items.length - 1;
|
|
return CommonActions.reset(obj);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
closure_0.setState((routes) => {
|
|
closure_0 = routes;
|
|
routes = routes.routes;
|
|
const routes1 = routes.routes;
|
|
const substr = routes1.slice(0, routes.findIndex((key) => key.key === closure_0.key));
|
|
const found = substr.filter((key) => {
|
|
const replacingRouteKeys = closure_0.replacingRouteKeys;
|
|
return replacingRouteKeys.includes(key.key);
|
|
});
|
|
const set = new Set(found.map((key) => key.key));
|
|
const obj = { routes: null, openingRouteKeys: null, closingRouteKeys: null, replacingRouteKeys: null };
|
|
const routes2 = routes.routes;
|
|
obj.routes = routes2.filter((key) => !set.has(key.key));
|
|
const openingRouteKeys = routes.openingRouteKeys;
|
|
obj.openingRouteKeys = openingRouteKeys.filter((item) => item !== closure_0.key);
|
|
const closingRouteKeys = routes.closingRouteKeys;
|
|
obj.closingRouteKeys = closingRouteKeys.filter((item) => item !== closure_0.key);
|
|
let replacingRouteKeys = routes.replacingRouteKeys;
|
|
obj.replacingRouteKeys = replacingRouteKeys.filter((item) => !set.has(item));
|
|
return obj;
|
|
});
|
|
};
|
|
tmp3Result.handleCloseRoute = (route) => {
|
|
route = route.route;
|
|
({ state, navigation } = closure_0.props);
|
|
let routes = state.routes;
|
|
if (routes.some((key) => key.key === route.key)) {
|
|
const obj2 = {};
|
|
const StackActions = StackView(1484).StackActions;
|
|
const merged = Object.assign(StackActions.pop());
|
|
obj2.source = route.key;
|
|
obj2.target = state.key;
|
|
navigation.dispatch(obj2);
|
|
} else {
|
|
closure_0.setState((routes) => {
|
|
const obj = { routes: null, openingRouteKeys: null, closingRouteKeys: null };
|
|
routes = routes.routes;
|
|
obj.routes = routes.filter((key) => key.key !== route.key);
|
|
const openingRouteKeys = routes.openingRouteKeys;
|
|
obj.openingRouteKeys = openingRouteKeys.filter((item) => item !== route.key);
|
|
const closingRouteKeys = routes.closingRouteKeys;
|
|
obj.closingRouteKeys = closingRouteKeys.filter((item) => item !== route.key);
|
|
return obj;
|
|
});
|
|
}
|
|
};
|
|
tmp3Result.handleTransitionStart = (route, closing) => {
|
|
const navigation = closure_0.props.navigation;
|
|
const obj = { type: "transitionStart", data: { closing }, target: route.route.key };
|
|
return navigation.emit(obj);
|
|
};
|
|
tmp3Result.handleTransitionEnd = (route, closing) => {
|
|
const navigation = closure_0.props.navigation;
|
|
const obj = { type: "transitionEnd", data: { closing }, target: route.route.key };
|
|
return navigation.emit(obj);
|
|
};
|
|
tmp3Result.handleGestureStart = (route) => {
|
|
const navigation = closure_0.props.navigation;
|
|
navigation.emit({ type: "gestureStart", target: route.route.key });
|
|
};
|
|
tmp3Result.handleGestureEnd = (route) => {
|
|
const navigation = closure_0.props.navigation;
|
|
navigation.emit({ type: "gestureEnd", target: route.route.key });
|
|
};
|
|
tmp3Result.handleGestureCancel = (route) => {
|
|
const navigation = closure_0.props.navigation;
|
|
navigation.emit({ type: "gestureCancel", target: route.route.key });
|
|
};
|
|
return tmp3Result;
|
|
}
|
|
}
|
|
_inherits(StackView, noop.Component);
|
|
const entry = {
|
|
key: "render",
|
|
value: function render() {
|
|
const self = this;
|
|
let props = this.props;
|
|
const state = props.state;
|
|
closure_2 = _objectWithoutProperties(props, closure_2);
|
|
({ routes: _objectWithoutProperties, descriptors: _classCallCheck, openingRouteKeys: closure_5, closingRouteKeys: _getPrototypeOf } = this.state);
|
|
const preloadedRoutes = state.preloadedRoutes;
|
|
StackView = preloadedRoutes.reduce((acc, key) => {
|
|
let describeResult = acc[key.key];
|
|
if (!describeResult) {
|
|
const props = self.props;
|
|
describeResult = props.describe(key, true);
|
|
}
|
|
acc[key.key] = describeResult;
|
|
return acc;
|
|
}, {});
|
|
const obj = { style: container.container, children: null };
|
|
const obj2 = {
|
|
children: self(StackView(state[13]).SafeAreaInsetsContext.Consumer, {
|
|
children(arg0) {
|
|
closure_0 = arg0;
|
|
return self(closure_0(state[14]).ModalPresentationContext.Consumer, {
|
|
children(arg0) {
|
|
closure_0 = arg0;
|
|
return self(closure_0(state[12]).HeaderShownContext.Consumer, {
|
|
children(isParentHeaderShown) {
|
|
const merged = Object.assign(closure_2);
|
|
return jsx(StackView(7117).CardStack, { insets: preloadedDescriptors, isParentHeaderShown, isParentModal: preloadedDescriptors, getPreviousRoute: self.getPreviousRoute, routes, openingRouteKeys, closingRouteKeys, onOpenRoute: self.handleOpenRoute, onCloseRoute: self.handleCloseRoute, onTransitionStart: self.handleTransitionStart, onTransitionEnd: self.handleTransitionEnd, renderHeader: self.renderHeader, state, descriptors, onGestureStart: self.handleGestureStart, onGestureEnd: self.handleGestureEnd, onGestureCancel: self.handleGestureCancel, preloadedDescriptors });
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
})
|
|
};
|
|
obj.children = self(StackView(state[12]).SafeAreaProviderCompat, obj2);
|
|
return self(GestureHandlerRootView, obj);
|
|
}
|
|
};
|
|
let items = [entry];
|
|
const entry1 = {
|
|
key: "getDerivedStateFromProps",
|
|
value: function getDerivedStateFromProps(state, previousState) {
|
|
let arr3 = state;
|
|
dependencyMap = previousState;
|
|
const items = [...state.state.preloadedRoutes];
|
|
const items1 = [];
|
|
if (previousState.previousState) {
|
|
HermesBuiltin.arraySpread(previousState.previousState.preloadedRoutes, HermesBuiltin.arraySpread(previousState.previousState.routes, 0));
|
|
arr3 = items1;
|
|
} else {
|
|
arr3 = items1;
|
|
}
|
|
const mapped = items.map((key) => key.key);
|
|
const mapped1 = arr3.map((key) => key.key);
|
|
if (typeof isArrayEqual === "function") {
|
|
arr3 = mapped1;
|
|
if (tmp5) {
|
|
if (previousState.routes.length) {
|
|
let routes = previousState.routes;
|
|
const found = routes.filter((key) => {
|
|
const closingRouteKeys = previousState.closingRouteKeys;
|
|
let hasItem = closingRouteKeys.includes(key.key);
|
|
if (hasItem) {
|
|
const routes = arr3.state.routes;
|
|
hasItem = !routes.some((key) => key.key === key.key);
|
|
}
|
|
return hasItem;
|
|
});
|
|
const routes1 = previousState.routes;
|
|
const found1 = routes1.filter((key) => {
|
|
const replacingRouteKeys = previousState.replacingRouteKeys;
|
|
let hasItem = replacingRouteKeys.includes(key.key);
|
|
if (hasItem) {
|
|
const routes = arr3.state.routes;
|
|
hasItem = !routes.some((key) => key.key === key.key);
|
|
}
|
|
return hasItem;
|
|
});
|
|
const routes2 = state.state.routes;
|
|
const substr = routes2.slice();
|
|
if (found1.length) {
|
|
const splice3 = substr.splice;
|
|
const items2 = [substr.length - 1, 0];
|
|
HermesBuiltin.arraySpread(found1, 2);
|
|
HermesBuiltin.apply(items2, substr);
|
|
}
|
|
if (found.length) {
|
|
const push = substr.push;
|
|
const items3 = [];
|
|
HermesBuiltin.arraySpread(found, 0);
|
|
HermesBuiltin.apply(items3, substr);
|
|
}
|
|
if (typeof isArrayEqual === "function") {
|
|
let mapped2 = substr;
|
|
if (!tmp72) {
|
|
closure_2 = items.reduce((acc, key) => {
|
|
acc[key.key] = key;
|
|
return acc;
|
|
}, {});
|
|
mapped2 = substr.map((item) => closure_2[item.key] || item);
|
|
}
|
|
const items4 = [];
|
|
HermesBuiltin.arraySpread(state.state.preloadedRoutes, HermesBuiltin.arraySpread(mapped2, 0));
|
|
const obj3 = {
|
|
routes: mapped2,
|
|
previousState: state.state,
|
|
descriptors: items4.reduce((acc, key) => {
|
|
let tmp = arr3.descriptors[key.key];
|
|
if (!tmp) {
|
|
tmp = previousState.descriptors[key.key];
|
|
}
|
|
acc[key.key] = tmp;
|
|
return acc;
|
|
}, {})
|
|
};
|
|
return obj3;
|
|
} else {
|
|
throw new TypeError("Trying to call a non-function");
|
|
}
|
|
}
|
|
}
|
|
if (state.state.index < state.state.routes.length - 1) {
|
|
const routes3 = state.state.routes;
|
|
let substr1 = routes3.slice(0, state.state.index + 1);
|
|
} else {
|
|
substr1 = state.state.routes;
|
|
}
|
|
let substr3 = substr1;
|
|
({ openingRouteKeys, closingRouteKeys } = previousState);
|
|
let replacingRouteKeys = previousState.replacingRouteKeys;
|
|
const found2 = closingRouteKeys.filter((item) => {
|
|
closure_0 = item;
|
|
return !substr3.some((key) => key.key === closure_0);
|
|
});
|
|
let found9 = found2;
|
|
const found3 = replacingRouteKeys.filter((item) => {
|
|
closure_0 = item;
|
|
return !substr3.some((key) => key.key === closure_0);
|
|
});
|
|
let items10 = found3;
|
|
let tmp6;
|
|
if (previousState.previousState) {
|
|
tmp6 = previousState.previousState.routes[previousState.previousState.index];
|
|
}
|
|
closure_6 = tmp6;
|
|
closure_7 = tmp7;
|
|
function isAnimationEnabled(arg0) {
|
|
|
|
}
|
|
if (tmp6) {
|
|
if (tmp6.key !== tmp7.key) {
|
|
if (arr3.some((key) => key.key === closure_7.key)) {
|
|
if (!substr1.some((key) => key.key === closure_6.key)) {
|
|
let animation;
|
|
if ((state.descriptors[tmp6.key] || previousState.descriptors[tmp6.key]) != null) {
|
|
animation = tmp18.options.animation;
|
|
}
|
|
const obj = arr3(7117);
|
|
let tmp9 = found3;
|
|
let tmp10 = found2;
|
|
let found4 = openingRouteKeys;
|
|
let arr11 = substr1;
|
|
if (tmp23) {
|
|
const items5 = [];
|
|
items5[HermesBuiltin.arraySpread(found2, 0)] = tmp6.key;
|
|
found9 = items5;
|
|
found4 = openingRouteKeys.filter((item) => item !== closure_6.key);
|
|
const found5 = found3.filter((item) => item !== closure_6.key);
|
|
items10 = found5;
|
|
const items6 = [];
|
|
items6[HermesBuiltin.arraySpread(substr1, 0)] = tmp6;
|
|
substr3 = items6;
|
|
tmp9 = found5;
|
|
tmp10 = items5;
|
|
arr11 = items6;
|
|
}
|
|
tmp23 = arr3(7117).getAnimationEnabled(animation) && !found2.includes(tmp6.key);
|
|
}
|
|
}
|
|
let animation1;
|
|
if ((state.descriptors[tmp7.key] || previousState.descriptors[tmp7.key]) != null) {
|
|
animation1 = tmp29.options.animation;
|
|
}
|
|
tmp9 = found3;
|
|
tmp10 = found2;
|
|
found4 = openingRouteKeys;
|
|
arr11 = substr1;
|
|
if (obj2.getAnimationEnabled(animation1)) {
|
|
tmp9 = found3;
|
|
tmp10 = found2;
|
|
found4 = openingRouteKeys;
|
|
arr11 = substr1;
|
|
if (!openingRouteKeys.includes(tmp7.key)) {
|
|
const items7 = [];
|
|
items7[HermesBuiltin.arraySpread(openingRouteKeys, 0)] = tmp7.key;
|
|
const found6 = found2.filter((item) => item !== closure_7.key);
|
|
found9 = found6;
|
|
const found7 = found3.filter((item) => item !== closure_7.key);
|
|
items10 = found7;
|
|
tmp9 = found7;
|
|
tmp10 = found6;
|
|
found4 = items7;
|
|
arr11 = substr1;
|
|
if (!substr1.some((key) => key.key === closure_6.key)) {
|
|
const found8 = items7.filter((item) => item !== closure_6.key);
|
|
let str = state.descriptors[tmp7.key] || previousState.descriptors[tmp7.key].options.animationTypeForReplace;
|
|
if (str == null) {
|
|
str = "push";
|
|
}
|
|
if ("pop" === str) {
|
|
const items8 = [];
|
|
items8[HermesBuiltin.arraySpread(found6, 0)] = tmp6.key;
|
|
found9 = items8;
|
|
found4 = found8.filter((item) => item !== closure_7.key);
|
|
const items9 = [];
|
|
items9[HermesBuiltin.arraySpread(substr1, 0)] = tmp6;
|
|
substr3 = items9;
|
|
tmp9 = found7;
|
|
tmp10 = items8;
|
|
arr11 = items9;
|
|
} else {
|
|
items10 = [];
|
|
items10[HermesBuiltin.arraySpread(found7, 0)] = tmp6.key;
|
|
found9 = found6.filter((item) => item !== closure_6.key);
|
|
const substr2 = substr1.slice();
|
|
substr3 = substr2;
|
|
substr2.splice(substr2.length - 1, 0, tmp6);
|
|
const routes4 = previousState.routes;
|
|
const found10 = routes4.filter((key) => {
|
|
let hasItem = items10.includes(key.key);
|
|
if (hasItem) {
|
|
hasItem = !substr3.some((key) => key.key === key.key);
|
|
}
|
|
return hasItem;
|
|
});
|
|
tmp9 = items10;
|
|
tmp10 = found9;
|
|
found4 = found8;
|
|
arr11 = substr2;
|
|
if (found10.length) {
|
|
const splice2 = substr2.splice;
|
|
const items11 = [substr2.length - 2, 0];
|
|
HermesBuiltin.arraySpread(found10, 2);
|
|
HermesBuiltin.apply(items11, substr2);
|
|
tmp9 = items10;
|
|
tmp10 = found9;
|
|
found4 = found8;
|
|
arr11 = substr2;
|
|
}
|
|
}
|
|
const tmp37 = state.descriptors[tmp7.key] || previousState.descriptors[tmp7.key];
|
|
}
|
|
}
|
|
}
|
|
obj2 = arr3(7117);
|
|
}
|
|
if (arr11.length) {
|
|
const items12 = [];
|
|
HermesBuiltin.arraySpread(state.state.preloadedRoutes, HermesBuiltin.arraySpread(arr11, 0));
|
|
const obj4 = {
|
|
routes: arr11,
|
|
previousState: state.state,
|
|
openingRouteKeys: found4,
|
|
closingRouteKeys: tmp10,
|
|
replacingRouteKeys: tmp9,
|
|
descriptors: items12.reduce((acc, key) => {
|
|
let tmp = arr3.descriptors[key.key];
|
|
if (!tmp) {
|
|
tmp = previousState.descriptors[key.key];
|
|
}
|
|
acc[key.key] = tmp;
|
|
return acc;
|
|
}, {})
|
|
};
|
|
return obj4;
|
|
} else {
|
|
const _Error = Error;
|
|
const error = new Error("There should always be at least one route in the navigation state.");
|
|
throw error;
|
|
}
|
|
}
|
|
tmp9 = found3;
|
|
tmp10 = found2;
|
|
found4 = openingRouteKeys;
|
|
arr11 = substr1;
|
|
if (tmp8) {
|
|
substr3 = substr1.slice();
|
|
const splice = substr3.splice;
|
|
const items13 = [substr3.length - 1, 0];
|
|
const routes5 = previousState.routes;
|
|
HermesBuiltin.arraySpread(routes5.filter((key) => {
|
|
if (typeof isAnimationEnabled === "function") {
|
|
let tmp2 = arr3.descriptors[key];
|
|
if (!tmp2) {
|
|
tmp2 = previousState.descriptors[key];
|
|
}
|
|
let animation;
|
|
if (tmp2 != null) {
|
|
animation = tmp2.options.animation;
|
|
}
|
|
let animationEnabled = StackView(7117).getAnimationEnabled(animation);
|
|
if (animationEnabled) {
|
|
let hasItem = items10.includes(key);
|
|
if (!hasItem) {
|
|
hasItem = found9.includes(key);
|
|
}
|
|
animationEnabled = hasItem;
|
|
}
|
|
return animationEnabled;
|
|
} else {
|
|
throw new TypeError("Trying to call a non-function");
|
|
}
|
|
}), 2);
|
|
HermesBuiltin.apply(items13, substr3);
|
|
tmp9 = found3;
|
|
tmp10 = found2;
|
|
found4 = openingRouteKeys;
|
|
arr11 = substr3;
|
|
}
|
|
tmp5 = mapped.length === mapped1.length && mapped.every((item, index) => Object.is(item, arr3[index]));
|
|
tmp8 = found3.length || found2.length;
|
|
} else {
|
|
throw new TypeError("Trying to call a non-function");
|
|
}
|
|
}
|
|
};
|
|
let items1 = [entry1];
|
|
const container = StyleSheet.create({ container: { flex: 1 } });
|
|
|
|
export const StackView = _createClass(StackView, items, items1);
|