636 lines
23 KiB
JavaScript
636 lines
23 KiB
JavaScript
// Module ID: 5555
|
|
// Function ID: 47171
|
|
// Name: _isNativeReflectConstruct
|
|
// Dependencies: [77, 6, 7, 15, 17, 18, 31, 27, 33, 5556, 5526, 5571, 5558, 5573, 5569, 5574, 5559, 5575]
|
|
|
|
// Module 5555 (_isNativeReflectConstruct)
|
|
import _defineProperty from "_defineProperty";
|
|
import result from "result";
|
|
import getActivityIndicator from "get ActivityIndicator";
|
|
import MaybeScreenContainer from "MaybeScreenContainer";
|
|
import StyleSheet from "StyleSheet";
|
|
import _inherits from "_inherits";
|
|
import importAllResult from "result";
|
|
import get_ActivityIndicator from "get ActivityIndicator";
|
|
import jsxProd from "jsxProd";
|
|
|
|
let Platform;
|
|
let StyleSheet;
|
|
let closure_10;
|
|
let closure_12;
|
|
let closure_13;
|
|
const require = arg1;
|
|
function _isNativeReflectConstruct() {
|
|
let closure_0 = !valueOf.call(Reflect.construct(Boolean, [], () => {
|
|
|
|
}));
|
|
function _isNativeReflectConstruct() {
|
|
return closure_0;
|
|
}
|
|
const result = _isNativeReflectConstruct();
|
|
}
|
|
({ Animated: closure_10, Platform, StyleSheet } = get_ActivityIndicator);
|
|
({ jsx: closure_12, jsxs: closure_13 } = jsxProd);
|
|
let closure_14 = Object.freeze({ options: {} });
|
|
function getInterpolationIndex(arg0, arg1) {
|
|
let diff = arg1 - 1;
|
|
let num = 0;
|
|
let num2 = 0;
|
|
if (diff >= 0) {
|
|
while (true) {
|
|
let tmp3 = arg0[diff];
|
|
let prop;
|
|
if (null != tmp3) {
|
|
prop = tmp3.descriptor.options.cardStyleInterpolator;
|
|
}
|
|
num2 = num;
|
|
if (prop !== tmp) {
|
|
break;
|
|
} else {
|
|
num = num + 1;
|
|
diff = diff - 1;
|
|
num2 = num;
|
|
if (diff < 0) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return num2;
|
|
}
|
|
function getIsModal(descriptor) {
|
|
if (arg2) {
|
|
return true;
|
|
} else {
|
|
let isModalPresentation = require(5556) /* _isNativeReflectConstruct */.getIsModalPresentation(descriptor.descriptor.options.cardStyleInterpolator);
|
|
if (isModalPresentation) {
|
|
isModalPresentation = 0 !== arg1;
|
|
}
|
|
return isModalPresentation;
|
|
}
|
|
}
|
|
function getHeaderHeights(arr) {
|
|
let closure_0 = arr;
|
|
let closure_1 = arg1;
|
|
let closure_2 = arg2;
|
|
let _defineProperty = arg3;
|
|
let result = arg4;
|
|
let getActivityIndicator = arg5;
|
|
return arr.reduce((arg0, descriptor) => {
|
|
const options = descriptor.descriptor.options;
|
|
let headerStatusBarHeight = options.headerStatusBarHeight;
|
|
if (undefined === headerStatusBarHeight) {
|
|
let num = 0;
|
|
if (!table) {
|
|
num = top.top;
|
|
}
|
|
headerStatusBarHeight = num;
|
|
}
|
|
let headerStyle = options.headerStyle;
|
|
if (!headerStyle) {
|
|
headerStyle = {};
|
|
}
|
|
const flattenResult = outer1_11.flatten(headerStyle);
|
|
if ("height" in flattenResult) {
|
|
if ("number" === typeof flattenResult.height) {
|
|
let height = flattenResult.height;
|
|
}
|
|
if ("number" !== typeof height) {
|
|
height = arr(table[10]).getDefaultHeaderHeight(result, tmp10, headerStatusBarHeight);
|
|
const obj2 = arr(table[10]);
|
|
}
|
|
arg0[descriptor.route.key] = height;
|
|
return arg0;
|
|
}
|
|
height = table2[descriptor.route.key];
|
|
}, {});
|
|
}
|
|
function getDistanceFromOptions(arg0, options) {
|
|
options = undefined;
|
|
if (null != options) {
|
|
options = options.options;
|
|
}
|
|
if (!options) {
|
|
options = {};
|
|
}
|
|
const gestureDirection = options.gestureDirection;
|
|
if (undefined !== gestureDirection) {
|
|
return importDefault(5558)(arg0, gestureDirection);
|
|
} else if ("modal" === tmp) {
|
|
let gestureDirection2 = require(5571) /* SlideFromRightIOS */.ModalTransition.gestureDirection;
|
|
} else {
|
|
gestureDirection2 = require(5571) /* SlideFromRightIOS */.DefaultTransition.gestureDirection;
|
|
}
|
|
}
|
|
function getProgressFromGesture(interpolate, width, options) {
|
|
let obj = { width: Math.max(1, width.width), height: Math.max(1, width.height) };
|
|
const tmp = getDistanceFromOptions(obj, options);
|
|
if (tmp > 0) {
|
|
obj = {};
|
|
const items = [0, tmp];
|
|
obj.inputRange = items;
|
|
obj.outputRange = [1, 0];
|
|
let interpolateResult = interpolate.interpolate(obj);
|
|
} else {
|
|
obj = {};
|
|
const items1 = [tmp, 0];
|
|
obj.inputRange = items1;
|
|
obj.outputRange = [0, 1];
|
|
interpolateResult = interpolate.interpolate(obj);
|
|
}
|
|
return interpolateResult;
|
|
}
|
|
const styles = StyleSheet.create({ container: { flex: 1 }, absolute: { position: "absolute", top: 0, left: 0, right: 0 }, floating: { zIndex: 1 } });
|
|
|
|
export default ((Component) => {
|
|
class CardStack {
|
|
constructor(arg0) {
|
|
self = this;
|
|
tmp = outer1_4(this, apply);
|
|
items = [];
|
|
items[0] = Component;
|
|
obj = outer1_7(apply);
|
|
tmp2 = outer1_6;
|
|
if (outer1_21()) {
|
|
tmp4 = globalThis;
|
|
_Reflect = Reflect;
|
|
tmp5 = outer1_7;
|
|
constructResult = Reflect.construct(obj, items, outer1_7(self).constructor);
|
|
} else {
|
|
constructResult = obj.apply(self, items);
|
|
}
|
|
tmp2Result = tmp2(self, constructResult);
|
|
apply = tmp2Result;
|
|
tmp2Result.handleLayout = (nativeEvent) => {
|
|
const layout = nativeEvent.nativeEvent.layout;
|
|
const height = layout.height;
|
|
const width = layout.width;
|
|
let closure_2 = { width, height };
|
|
height.setState((layout, insets) => {
|
|
if (height !== layout.layout.height) {
|
|
const obj = { layout: closure_2, headerHeights: outer3_17(layout.scenes, insets.insets, insets.isParentHeaderShown, insets.isParentModal, closure_2, layout.headerHeights) };
|
|
let tmp2 = obj;
|
|
} else {
|
|
tmp2 = null;
|
|
}
|
|
return tmp2;
|
|
});
|
|
};
|
|
tmp2Result.handleHeaderLayout = (arg0) => {
|
|
let closure_0;
|
|
let closure_1;
|
|
({ route: closure_0, height: closure_1 } = arg0);
|
|
tmp2Result.setState((headerHeights) => {
|
|
headerHeights = headerHeights.headerHeights;
|
|
let tmp = null;
|
|
if (headerHeights[closure_0.key] !== closure_1) {
|
|
const obj = {};
|
|
const _Object = Object;
|
|
obj.headerHeights = Object.assign({}, headerHeights, outer3_3({}, closure_0.key, closure_1));
|
|
tmp = obj;
|
|
}
|
|
return tmp;
|
|
});
|
|
};
|
|
tmp2Result.getFocusedRoute = () => {
|
|
const state = tmp2Result.props.state;
|
|
return state.routes[state.index];
|
|
};
|
|
tmp2Result.getPreviousScene = (route) => {
|
|
const scenes = previousRoute.state.scenes;
|
|
previousRoute = previousRoute.props.getPreviousRoute({ route: route.route });
|
|
if (previousRoute) {
|
|
return scenes.find((descriptor) => descriptor.descriptor.route.key === previousRoute.key);
|
|
}
|
|
const obj = { route: route.route };
|
|
};
|
|
obj = { routes: [], scenes: [], gestures: {}, layout: CardStack(outer1_2[10]).SafeAreaProviderCompat.initialMetrics.frame, descriptors: tmp2Result.props.descriptors, headerHeights: {} };
|
|
tmp2Result.state = obj;
|
|
return tmp2Result;
|
|
}
|
|
}
|
|
callback2(CardStack, Component);
|
|
let obj = {
|
|
key: "render",
|
|
value: function render() {
|
|
let closure_1;
|
|
let closure_10;
|
|
let closure_11;
|
|
let closure_12;
|
|
let closure_13;
|
|
let closure_17;
|
|
let closure_2;
|
|
let _defineProperty;
|
|
let result;
|
|
let MaybeScreenContainer;
|
|
let StyleSheet;
|
|
let _inherits;
|
|
let closure_9;
|
|
let detachInactiveScreens;
|
|
let headerHeights;
|
|
let renderHeader;
|
|
let routes;
|
|
let state;
|
|
let self = this;
|
|
self = this;
|
|
const props = this.props;
|
|
({ insets: closure_1, state, routes, closingRouteKeys: closure_2, onOpenRoute: _defineProperty, onCloseRoute: result, renderHeader } = props);
|
|
({ renderScene: MaybeScreenContainer, isParentHeaderShown: StyleSheet, isParentModal: _inherits, onTransitionStart: closure_9, onTransitionEnd: closure_10, onGestureStart: closure_11, onGestureEnd: closure_12, onGestureCancel: closure_13, detachInactiveScreens } = props);
|
|
let closure_14 = tmp;
|
|
const state2 = self.state;
|
|
const scenes = state2.scenes;
|
|
const layout = state2.layout;
|
|
({ gestures: closure_17, headerHeights } = state2);
|
|
let closure_19 = tmp2;
|
|
const scenes1 = self.state.scenes;
|
|
const substr = scenes1.slice(-2);
|
|
const someResult = substr.some((descriptor) => {
|
|
let options = descriptor.descriptor.options;
|
|
if (null == options) {
|
|
options = {};
|
|
}
|
|
const headerShown = options.headerShown;
|
|
let tmp = !options.headerTransparent;
|
|
if (tmp) {
|
|
tmp = false !== (undefined === headerShown || headerShown);
|
|
const tmp2 = undefined === headerShown || headerShown;
|
|
}
|
|
if (tmp) {
|
|
tmp = "screen" !== options.headerMode;
|
|
}
|
|
return !tmp;
|
|
});
|
|
let num = 1;
|
|
let c21 = 1;
|
|
let diff = scenes.length - 1;
|
|
if (diff >= 0) {
|
|
while (true) {
|
|
let options = scenes[diff].descriptor.options;
|
|
let detachPreviousScreen = options.detachPreviousScreen;
|
|
if (undefined === detachPreviousScreen) {
|
|
let tmp5 = "transparentModal" !== options.presentation;
|
|
if (tmp5) {
|
|
let tmp6 = CardStack;
|
|
let tmp7 = outer1_2;
|
|
let obj1 = CardStack(outer1_2[9]);
|
|
let tmp8 = !obj1.getIsModalPresentation(options.cardStyleInterpolator);
|
|
if (!tmp8) {
|
|
let tmp9 = outer1_1;
|
|
let tmp10 = outer1_2;
|
|
tmp8 = diff !== outer1_1(outer1_2[13])(scenes, (descriptor) => {
|
|
const cardStyleInterpolator = descriptor.descriptor.options.cardStyleInterpolator;
|
|
let tmp = cardStyleInterpolator === CardStack(outer2_2[14]).forModalPresentationIOS;
|
|
if (!tmp) {
|
|
let name;
|
|
if (null != cardStyleInterpolator) {
|
|
name = cardStyleInterpolator.name;
|
|
}
|
|
tmp = "forModalPresentationIOS" === name;
|
|
}
|
|
return tmp;
|
|
});
|
|
}
|
|
tmp5 = tmp8;
|
|
}
|
|
detachPreviousScreen = tmp5;
|
|
}
|
|
if (false === detachPreviousScreen) {
|
|
let sum = num + 1;
|
|
c21 = sum;
|
|
let tmp11 = sum;
|
|
diff = diff - 1;
|
|
num = tmp11;
|
|
if (diff < 0) {
|
|
break;
|
|
}
|
|
} else {
|
|
tmp11 = num;
|
|
if (diff <= scenes.length - 2) {
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
let obj = {};
|
|
obj = { mode: "float", layout, scenes, getPreviousScene: self.getPreviousScene, getFocusedRoute: self.getFocusedRoute, onContentHeightChange: self.handleHeaderLayout };
|
|
let items = [outer1_20.floating, ];
|
|
let tmp14 = someResult;
|
|
if (someResult) {
|
|
obj1 = { height: headerHeights[tmp2.key] };
|
|
const items1 = [obj1, outer1_20.absolute];
|
|
tmp14 = items1;
|
|
}
|
|
items[1] = tmp14;
|
|
obj.style = items;
|
|
obj.children = renderHeader(obj);
|
|
const tmp13Result = outer1_12(outer1_9.Fragment, obj, "header");
|
|
let obj2 = {};
|
|
let tmp18 = null;
|
|
if (!someResult) {
|
|
tmp18 = tmp13Result;
|
|
}
|
|
const items2 = [tmp18, , ];
|
|
let obj3 = {
|
|
enabled: undefined === detachInactiveScreens || detachInactiveScreens,
|
|
style: outer1_20.container,
|
|
onLayout: self.handleLayout,
|
|
children: routes.map((key, index) => {
|
|
let bottom;
|
|
let freezeOnBlur;
|
|
let headerStyle;
|
|
let headerTransparent;
|
|
let left;
|
|
let right;
|
|
let top;
|
|
let num = 0;
|
|
if (index >= arg2.length - c21 - 1) {
|
|
let num2 = 2;
|
|
if (index !== arg2.length - 1) {
|
|
let num3 = 0;
|
|
if (index >= arg2.length - c21) {
|
|
num3 = 1;
|
|
}
|
|
num2 = num3;
|
|
}
|
|
let num4 = 1;
|
|
if (scenes[arg2.length - 1]) {
|
|
const current = tmp3.progress.current;
|
|
let obj = { inputRange: [0, 0.99999, 1] };
|
|
const items = [1, 1, num2];
|
|
obj.outputRange = items;
|
|
obj.extrapolate = "clamp";
|
|
num4 = current.interpolate(obj);
|
|
}
|
|
num = num4;
|
|
const tmp2 = scenes;
|
|
}
|
|
const options = tmp.descriptor.options;
|
|
const headerShown = options.headerShown;
|
|
const headerTintColor = options.headerTintColor;
|
|
let num5 = 0;
|
|
({ headerTransparent, headerStyle, freezeOnBlur } = options);
|
|
({ top, right, bottom, left } = closure_1);
|
|
if (false !== (undefined === headerShown || headerShown)) {
|
|
num5 = headerHeights[key.key];
|
|
}
|
|
let isDarkResult;
|
|
if (undefined === headerShown || headerShown) {
|
|
if ("string" === typeof headerTintColor) {
|
|
isDarkResult = outer2_1(outer2_2[16])(headerTintColor).isDark();
|
|
const obj3 = outer2_1(outer2_2[16])(headerTintColor);
|
|
} else {
|
|
const flattenResult = outer2_11.flatten(headerStyle);
|
|
let tmp10 = flattenResult;
|
|
if (flattenResult) {
|
|
tmp10 = "backgroundColor" in flattenResult;
|
|
}
|
|
if (tmp10) {
|
|
tmp10 = "string" === typeof flattenResult.backgroundColor;
|
|
}
|
|
if (tmp10) {
|
|
isDarkResult = !outer2_1(outer2_2[16])(flattenResult.backgroundColor).isDark();
|
|
const obj2 = outer2_1(outer2_2[16])(flattenResult.backgroundColor);
|
|
}
|
|
}
|
|
}
|
|
const tmp15 = outer2_15(scenes, index);
|
|
let presentation;
|
|
if (null != scenes[index + 1]) {
|
|
presentation = tmp17.descriptor.options.presentation;
|
|
}
|
|
let detachPreviousScreen;
|
|
if (null != scenes[index + 1]) {
|
|
detachPreviousScreen = tmp19.descriptor.options.detachPreviousScreen;
|
|
}
|
|
obj = { style: outer2_11.absoluteFill, enabled: closure_14, active: num, freezeOnBlur, pointerEvents: "box-none" };
|
|
obj = { index, interpolationIndex: tmp15, modal: outer2_16(scenes[index], tmp15, _inherits), active: index === arg2.length - 1, focused: tmp2.key === key.key };
|
|
const tmp16 = outer2_16(scenes[index], tmp15, _inherits);
|
|
obj.closing = closure_2.includes(key.key);
|
|
obj.layout = layout;
|
|
obj.gesture = table[key.key];
|
|
obj.scene = scenes[index];
|
|
obj.safeAreaInsetTop = top;
|
|
obj.safeAreaInsetRight = right;
|
|
obj.safeAreaInsetBottom = bottom;
|
|
obj.safeAreaInsetLeft = left;
|
|
obj.onGestureStart = closure_11;
|
|
obj.onGestureCancel = closure_13;
|
|
obj.onGestureEnd = closure_12;
|
|
obj.headerHeight = num5;
|
|
obj.isParentHeaderShown = StyleSheet;
|
|
({ handleHeaderLayout: obj5.onHeaderHeightChange, getPreviousScene: obj5.getPreviousScene, getFocusedRoute: obj5.getFocusedRoute } = self);
|
|
obj.headerDarkContent = isDarkResult;
|
|
let tmp23 = closure_20;
|
|
if (closure_20) {
|
|
tmp23 = !headerTransparent;
|
|
}
|
|
obj.hasAbsoluteFloatHeader = tmp23;
|
|
obj.renderHeader = renderHeader;
|
|
obj.renderScene = MaybeScreenContainer;
|
|
obj.onOpenRoute = _defineProperty;
|
|
obj.onCloseRoute = result;
|
|
obj.onTransitionStart = closure_9;
|
|
obj.onTransitionEnd = closure_10;
|
|
obj.isNextScreenTransparent = "transparentModal" === presentation;
|
|
obj.detachCurrentScreen = false !== detachPreviousScreen;
|
|
obj.children = outer2_12(outer2_1(outer2_2[17]), obj);
|
|
return outer2_12(CardStack(outer2_2[15]).MaybeScreen, obj, key.key);
|
|
})
|
|
};
|
|
items2[1] = outer1_12(CardStack(outer1_2[15]).MaybeScreenContainer, obj3);
|
|
let tmp19 = null;
|
|
if (someResult) {
|
|
tmp19 = tmp13Result;
|
|
}
|
|
items2[2] = tmp19;
|
|
obj2.children = items2;
|
|
return outer1_13(CardStack(outer1_2[10]).Background, obj2);
|
|
}
|
|
};
|
|
let items = [obj];
|
|
obj = {
|
|
key: "getDerivedStateFromProps",
|
|
value: function getDerivedStateFromProps(routes, routes2) {
|
|
let closure_0 = routes;
|
|
let closure_1 = routes2;
|
|
if (routes.routes === routes2.routes) {
|
|
if (routes.descriptors === routes2.descriptors) {
|
|
return null;
|
|
}
|
|
}
|
|
routes = routes.routes;
|
|
const reduced = routes.reduce((arg0, key) => {
|
|
let options;
|
|
if (null != closure_0.descriptors[key.key]) {
|
|
options = tmp.options;
|
|
}
|
|
if (!options) {
|
|
options = {};
|
|
}
|
|
let value = closure_1.gestures[key.key];
|
|
if (!value) {
|
|
const Value = outer2_10.Value;
|
|
const openingRouteKeys = closure_0.openingRouteKeys;
|
|
let num = 0;
|
|
if (openingRouteKeys.includes(key.key)) {
|
|
num = 0;
|
|
if (false !== tmp2) {
|
|
num = outer2_18(closure_1.layout, tmp);
|
|
}
|
|
}
|
|
const prototype = Value.prototype;
|
|
value = new Value(num);
|
|
}
|
|
arg0[key.key] = value;
|
|
return arg0;
|
|
}, {});
|
|
const routes1 = routes.routes;
|
|
const mapped = routes1.map((route) => {
|
|
let closure_0 = tmp3;
|
|
let tmp9 = closure_0.descriptors[route.key];
|
|
if (!tmp9) {
|
|
tmp9 = closure_1.descriptors[route.key];
|
|
}
|
|
if (tmp9) {
|
|
let key;
|
|
if (null != tmp2) {
|
|
key = tmp2.key;
|
|
}
|
|
let tmp15 = closure_0.descriptors[key];
|
|
if (!tmp15) {
|
|
let key1;
|
|
if (null != tmp2) {
|
|
key1 = tmp2.key;
|
|
}
|
|
tmp15 = closure_1.descriptors[key1];
|
|
}
|
|
let key2;
|
|
if (null != tmp) {
|
|
key2 = tmp.key;
|
|
}
|
|
let tmp20 = closure_0.descriptors[key2];
|
|
if (!tmp20) {
|
|
let key3;
|
|
if (null != tmp) {
|
|
key3 = tmp.key;
|
|
}
|
|
tmp20 = closure_1.descriptors[key3];
|
|
}
|
|
if (arg1 !== arg2.length - 1) {
|
|
if (tmp15) {
|
|
if ("transparentModal" !== tmp15.options.presentation) {
|
|
let options = tmp15.options;
|
|
}
|
|
if ("modal" === options.presentation) {
|
|
let DefaultTransition = CardStack(outer2_2[11]).ModalTransition;
|
|
} else if ("transparentModal" === options.presentation) {
|
|
DefaultTransition = CardStack(outer2_2[11]).ModalFadeTransition;
|
|
} else {
|
|
DefaultTransition = CardStack(outer2_2[11]).DefaultTransition;
|
|
}
|
|
const animationEnabled = options.animationEnabled;
|
|
const gestureEnabled = options.gestureEnabled;
|
|
let gestureDirection = options.gestureDirection;
|
|
if (undefined === gestureDirection) {
|
|
gestureDirection = DefaultTransition.gestureDirection;
|
|
}
|
|
let transitionSpec = options.transitionSpec;
|
|
if (undefined === transitionSpec) {
|
|
transitionSpec = DefaultTransition.transitionSpec;
|
|
}
|
|
const cardStyleInterpolator = options.cardStyleInterpolator;
|
|
if (undefined !== cardStyleInterpolator) {
|
|
let headerStyleInterpolator = options.headerStyleInterpolator;
|
|
if (undefined === headerStyleInterpolator) {
|
|
headerStyleInterpolator = DefaultTransition.headerStyleInterpolator;
|
|
}
|
|
let cardOverlayEnabled = options.cardOverlayEnabled;
|
|
if (undefined === cardOverlayEnabled) {
|
|
let isModalPresentation = "transparentModal" !== options.presentation;
|
|
if (!isModalPresentation) {
|
|
let obj = CardStack(outer2_2[9]);
|
|
isModalPresentation = obj.getIsModalPresentation(cardStyleInterpolator);
|
|
}
|
|
cardOverlayEnabled = isModalPresentation;
|
|
}
|
|
let str5 = tmp9.options.headerMode;
|
|
if (null == str5) {
|
|
let tmp37 = "modal" !== options.presentation;
|
|
if (tmp37) {
|
|
tmp37 = "transparentModal" !== options.presentation;
|
|
}
|
|
if (tmp37) {
|
|
let presentation;
|
|
if (null != tmp15) {
|
|
presentation = tmp15.options.presentation;
|
|
}
|
|
tmp37 = "modal" !== presentation;
|
|
}
|
|
if (tmp37) {
|
|
let presentation1;
|
|
if (null != tmp15) {
|
|
presentation1 = tmp15.options.presentation;
|
|
}
|
|
tmp37 = "transparentModal" !== presentation1;
|
|
}
|
|
str5 = "screen";
|
|
if (tmp37) {
|
|
let obj1 = CardStack(outer2_2[9]);
|
|
const isModalPresentation1 = obj1.getIsModalPresentation(cardStyleInterpolator);
|
|
str5 = "screen";
|
|
}
|
|
}
|
|
obj = { route };
|
|
const _Object = Object;
|
|
obj = {};
|
|
const _Object2 = Object;
|
|
obj1 = { animationEnabled: tmp29, cardOverlayEnabled, cardStyleInterpolator, gestureDirection, gestureEnabled: tmp30, headerStyleInterpolator, transitionSpec, headerMode: str5 };
|
|
obj.options = Object.assign({}, tmp9.options, obj1);
|
|
obj.descriptor = Object.assign({}, tmp9, obj);
|
|
const obj2 = { current: outer2_19(tmp4, closure_1.layout, tmp9) };
|
|
let tmp46;
|
|
if (tmp7) {
|
|
let presentation2;
|
|
if (null != tmp15) {
|
|
presentation2 = tmp15.options.presentation;
|
|
}
|
|
if ("transparentModal" !== presentation2) {
|
|
tmp46 = outer2_19(tmp7, closure_1.layout, tmp15);
|
|
}
|
|
}
|
|
obj2.next = tmp46;
|
|
let tmp50;
|
|
if (tmp5) {
|
|
tmp50 = outer2_19(tmp5, closure_1.layout, tmp20);
|
|
}
|
|
obj2.previous = tmp50;
|
|
obj.progress = obj2;
|
|
const items = [closure_1.layout, tmp9, tmp15, tmp20, tmp4, tmp7, tmp5];
|
|
obj.__memo = items;
|
|
let tmp54 = obj;
|
|
if (tmp3) {
|
|
const __memo = obj.__memo;
|
|
tmp54 = obj;
|
|
if (__memo.every((arg0, arg1) => tmp3.__memo[arg1] === arg0)) {
|
|
tmp54 = tmp3;
|
|
}
|
|
}
|
|
return tmp54;
|
|
} else if (false === tmp29) {
|
|
let cardStyleInterpolator2 = CardStack(outer2_2[14]).forNoAnimation;
|
|
} else {
|
|
cardStyleInterpolator2 = DefaultTransition.cardStyleInterpolator;
|
|
}
|
|
tmp30 = undefined !== gestureEnabled && gestureEnabled;
|
|
}
|
|
}
|
|
options = tmp9.options;
|
|
}
|
|
});
|
|
return { routes: routes.routes, scenes: mapped, gestures: reduced, descriptors: routes.descriptors, headerHeights: outer1_17(mapped, routes.insets, routes.isParentHeaderShown, routes.isParentModal, routes2.layout, routes2.headerHeights) };
|
|
}
|
|
};
|
|
let items1 = [obj];
|
|
return callback(CardStack, items, items1);
|
|
})(importAllResult.Component);
|