1928 lines
62 KiB
JavaScript
1928 lines
62 KiB
JavaScript
// Module ID: 13244
|
|
// Function ID: 13245
|
|
// Name: _isNativeReflectConstruct
|
|
// Dependencies: [32, 41, 42, 93, 95, 98, 19, 17, 21, 8152, 13245, 13247, 4018]
|
|
|
|
// Module 13244 (_isNativeReflectConstruct)
|
|
import _slicedToArray from "_slicedToArray";
|
|
import _classCallCheck from "_classCallCheck";
|
|
import _possibleConstructorReturn from "_possibleConstructorReturn";
|
|
import _getPrototypeOf from "_getPrototypeOf";
|
|
import importDefaultResult from "_createClass";
|
|
import "noop";
|
|
import get_ActivityIndicator from "get ActivityIndicator";
|
|
import { jsx } from "jsxProd";
|
|
import importDefaultResult1 from "_inherits";
|
|
import importDefaultResult3 from "emptyFunction";
|
|
import importDefaultResult4 from "emptyFunction";
|
|
|
|
let FlatList;
|
|
let I18nManager;
|
|
let Platform;
|
|
let ScrollView;
|
|
let c9;
|
|
let metroImportAll;
|
|
const Carousel = arg1;
|
|
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);
|
|
}
|
|
let closure_0 = !callResult;
|
|
function _isNativeReflectConstruct() {
|
|
return closure_0;
|
|
}
|
|
return _isNativeReflectConstruct();
|
|
} catch (err) {
|
|
}
|
|
}
|
|
const Animated = get_ActivityIndicator.Animated;
|
|
({ Easing: metroImportAll, FlatList, Platform, View: c9, I18nManager, ScrollView } = get_ActivityIndicator);
|
|
let animatedComponent = null;
|
|
if (FlatList) {
|
|
animatedComponent = Animated.createAnimatedComponent(FlatList);
|
|
}
|
|
let closure_13 = Animated.createAnimatedComponent(ScrollView);
|
|
const isRTL = I18nManager.isRTL;
|
|
class Carousel {
|
|
constructor(arg0) {
|
|
self = this;
|
|
tmp = _isNativeReflectConstruct(this, Carousel);
|
|
items = [];
|
|
items[0] = global;
|
|
tmp2 = _isNativeReflectConstruct;
|
|
obj = _isNativeReflectConstruct(Carousel);
|
|
tmp3 = _isNativeReflectConstruct;
|
|
if (_isNativeReflectConstruct()) {
|
|
tmp5 = globalThis;
|
|
_Reflect = Reflect;
|
|
constructResult = Reflect.construct(obj, items, tmp2(self).constructor);
|
|
} else {
|
|
constructResult = obj.apply(self, items);
|
|
}
|
|
tmp3Result = tmp3(self, constructResult);
|
|
tmp3Result.state = { hideCarousel: true, interpolators: [] };
|
|
_getFirstItemResult = tmp3Result._getFirstItem(global.firstItem);
|
|
tmp3Result._activeItem = _getFirstItemResult;
|
|
tmp3Result._previousActiveItem = _getFirstItemResult;
|
|
tmp3Result._previousFirstItem = _getFirstItemResult;
|
|
tmp3Result._previousItemsLength = _getFirstItemResult;
|
|
tmp3Result._mounted = false;
|
|
tmp3Result._positions = [];
|
|
tmp3Result._currentContentOffset = 0;
|
|
tmp3Result._canFireBeforeCallback = false;
|
|
tmp3Result._canFireCallback = false;
|
|
tmp3Result._scrollOffsetRef = null;
|
|
tmp3Result._onScrollTriggered = true;
|
|
tmp3Result._lastScrollDate = 0;
|
|
tmp3Result._scrollEnabled = false !== global.scrollEnabled;
|
|
_initPositionsAndInterpolators = tmp3Result._initPositionsAndInterpolators;
|
|
tmp3Result._initPositionsAndInterpolators = _initPositionsAndInterpolators.bind(tmp3Result);
|
|
_renderItem = tmp3Result._renderItem;
|
|
tmp3Result._renderItem = _renderItem.bind(tmp3Result);
|
|
_onSnap = tmp3Result._onSnap;
|
|
tmp3Result._onSnap = _onSnap.bind(tmp3Result);
|
|
_onLayout = tmp3Result._onLayout;
|
|
tmp3Result._onLayout = _onLayout.bind(tmp3Result);
|
|
_onScroll = tmp3Result._onScroll;
|
|
tmp3Result._onScroll = _onScroll.bind(tmp3Result);
|
|
bindResult = undefined;
|
|
if (global.enableSnap) {
|
|
_onScrollBeginDrag = tmp3Result._onScrollBeginDrag;
|
|
bindResult = _onScrollBeginDrag.bind(tmp3Result);
|
|
}
|
|
tmp3Result._onScrollBeginDrag = bindResult;
|
|
if (global.enableSnap) {
|
|
_onScrollEnd = tmp3Result._onScrollEnd;
|
|
bindResult1 = _onScrollEnd.bind(tmp3Result);
|
|
}
|
|
tmp3Result._onScrollEnd = bindResult1;
|
|
bindResult2 = undefined;
|
|
if (!global.enableMomentum) {
|
|
_onScrollEndDrag = tmp3Result._onScrollEndDrag;
|
|
bindResult2 = _onScrollEndDrag.bind(tmp3Result);
|
|
}
|
|
tmp3Result._onScrollEndDrag = bindResult2;
|
|
bindResult3 = undefined;
|
|
if (global.enableMomentum) {
|
|
_onMomentumScrollEnd = tmp3Result._onMomentumScrollEnd;
|
|
bindResult3 = _onMomentumScrollEnd.bind(tmp3Result);
|
|
}
|
|
tmp3Result._onMomentumScrollEnd = bindResult3;
|
|
_onTouchStart = tmp3Result._onTouchStart;
|
|
tmp3Result._onTouchStart = _onTouchStart.bind(tmp3Result);
|
|
_onTouchEnd = tmp3Result._onTouchEnd;
|
|
tmp3Result._onTouchEnd = _onTouchEnd.bind(tmp3Result);
|
|
_onTouchRelease = tmp3Result._onTouchRelease;
|
|
tmp3Result._onTouchRelease = _onTouchRelease.bind(tmp3Result);
|
|
_getKeyExtractor = tmp3Result._getKeyExtractor;
|
|
tmp3Result._getKeyExtractor = _getKeyExtractor.bind(tmp3Result);
|
|
_setScrollHandlerResult = tmp3Result._setScrollHandler(global);
|
|
tmp3Result._ignoreNextMomentum = false;
|
|
if (!require("get ColorPropType").ViewPropTypes) {
|
|
tmp12 = globalThis;
|
|
_console = console;
|
|
str = "react-native-snap-carousel: It is recommended to use at least version 0.44 of React Native with the plugin";
|
|
warnResult = console.warn("react-native-snap-carousel: It is recommended to use at least version 0.44 of React Native with the plugin");
|
|
}
|
|
vertical = global.vertical;
|
|
if (!vertical) {
|
|
tmp14 = global.sliderWidth && global.itemWidth;
|
|
vertical = tmp14;
|
|
}
|
|
if (!vertical) {
|
|
tmp15 = globalThis;
|
|
_console2 = console;
|
|
str2 = "react-native-snap-carousel: You need to specify both `sliderWidth` and `itemWidth` for horizontal carousels";
|
|
errorResult = console.error("react-native-snap-carousel: You need to specify both `sliderWidth` and `itemWidth` for horizontal carousels");
|
|
}
|
|
vertical2 = global.vertical;
|
|
tmp17 = !vertical2;
|
|
if (vertical2) {
|
|
tmp18 = global.sliderHeight && global.itemHeight;
|
|
tmp17 = tmp18;
|
|
}
|
|
if (!tmp17) {
|
|
tmp19 = globalThis;
|
|
_console3 = console;
|
|
str3 = "react-native-snap-carousel: You need to specify both `sliderHeight` and `itemHeight` for vertical carousels";
|
|
errorResult1 = console.error("react-native-snap-carousel: You need to specify both `sliderHeight` and `itemHeight` for vertical carousels");
|
|
}
|
|
tmp21 = global.apparitionDelay && !global.useScrollView;
|
|
if (tmp21) {
|
|
tmp22 = globalThis;
|
|
_console4 = console;
|
|
str4 = "react-native-snap-carousel: Using `apparitionDelay` on Android is not recommended since it can lead to rendering issues";
|
|
warnResult1 = console.warn("react-native-snap-carousel: Using `apparitionDelay` on Android is not recommended since it can lead to rendering issues");
|
|
}
|
|
tmp24 = global.customAnimationType || global.customAnimationOptions;
|
|
if (tmp24) {
|
|
tmp25 = globalThis;
|
|
_console5 = console;
|
|
str5 = "react-native-snap-carousel: Props `customAnimationType` and `customAnimationOptions` have been renamed to `activeAnimationType` and `activeAnimationOptions`";
|
|
warnResult2 = console.warn("react-native-snap-carousel: Props `customAnimationType` and `customAnimationOptions` have been renamed to `activeAnimationType` and `activeAnimationOptions`");
|
|
}
|
|
if (global.onScrollViewScroll) {
|
|
tmp27 = globalThis;
|
|
_console6 = console;
|
|
str6 = "react-native-snap-carousel: Prop `onScrollViewScroll` has been removed. Use `onScroll` instead";
|
|
errorResult2 = console.error("react-native-snap-carousel: Prop `onScrollViewScroll` has been removed. Use `onScroll` instead");
|
|
}
|
|
return tmp3Result;
|
|
}
|
|
}
|
|
require("_inherits")(Carousel, require("noop").Component);
|
|
let obj = {
|
|
key: "componentDidMount",
|
|
value: function componentDidMount() {
|
|
let dependencyMap;
|
|
let importDefault;
|
|
const self = this;
|
|
const props = this.props;
|
|
({ apparitionDelay: importDefault, autoplay: dependencyMap } = props);
|
|
let _slicedToArray = this._getFirstItem(props.firstItem);
|
|
function apparitionCallback() {
|
|
|
|
}
|
|
this._mounted = true;
|
|
let result = this._initPositionsAndInterpolators();
|
|
const animationFrame = requestAnimationFrame(() => {
|
|
if (self._mounted) {
|
|
obj._snapToItem(_slicedToArray, false, false, true, false);
|
|
const result = obj._hackActiveSlideAnimation(_slicedToArray, "start", true);
|
|
if (closure_1) {
|
|
const _setTimeout = setTimeout;
|
|
obj._apparitionTimeout = setTimeout(() => {
|
|
if (typeof closure_0 !== "fileFinishedImporting") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
state.setState({ hideCarousel: false });
|
|
if (closure_2) {
|
|
state.startAutoplay();
|
|
}
|
|
}, tmp6);
|
|
} else {
|
|
if (typeof apparitionCallback !== "fileFinishedImporting") {
|
|
HermesBuiltin.throwTypeError();
|
|
}
|
|
obj.setState({ hideCarousel: false });
|
|
if (closure_2) {
|
|
obj.startAutoplay();
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
};
|
|
let items = [
|
|
obj,
|
|
{
|
|
key: "shouldComponentUpdate",
|
|
value: function shouldComponentUpdate(arg0, arg1) {
|
|
let tmp2 = false === this.props.shouldOptimizeUpdates;
|
|
if (!tmp2) {
|
|
tmp2 = importDefault(13245)(tmp, arg0, arg1);
|
|
}
|
|
return tmp2;
|
|
}
|
|
},
|
|
{
|
|
key: "componentDidUpdate",
|
|
value: function componentDidUpdate(sliderWidth) {
|
|
let itemHeight;
|
|
let itemWidth;
|
|
let scrollEnabled;
|
|
let sliderHeight;
|
|
const self = this;
|
|
const props = this.props;
|
|
({ itemHeight, itemWidth, scrollEnabled, sliderHeight, sliderWidth } = props);
|
|
const _getCustomDataLengthResult = this._getCustomDataLength(this.props);
|
|
if (_getCustomDataLengthResult) {
|
|
const _getFirstItemResult = self._getFirstItem(props.firstItem, self.props);
|
|
if (self._activeItem) {
|
|
let _activeItem = self._activeItem;
|
|
} else {
|
|
_activeItem = _getFirstItemResult;
|
|
}
|
|
let tmp4 = sliderWidth;
|
|
if (sliderWidth) {
|
|
tmp4 = sliderWidth !== sliderWidth.sliderWidth;
|
|
}
|
|
let tmp5 = sliderHeight;
|
|
if (sliderHeight) {
|
|
tmp5 = sliderHeight !== sliderWidth.sliderHeight;
|
|
}
|
|
let tmp6 = itemWidth;
|
|
if (itemWidth) {
|
|
tmp6 = itemWidth !== sliderWidth.itemWidth;
|
|
}
|
|
let tmp7 = itemHeight;
|
|
if (itemHeight) {
|
|
tmp7 = itemHeight !== sliderWidth.itemHeight;
|
|
}
|
|
if (_activeItem > _getCustomDataLengthResult - 1) {
|
|
_activeItem = _getCustomDataLengthResult - 1;
|
|
}
|
|
if (scrollEnabled !== sliderWidth.scrollEnabled) {
|
|
self._setScrollEnabled(scrollEnabled);
|
|
}
|
|
if (this.state.interpolators.length === _getCustomDataLengthResult) {
|
|
if (!tmp4) {
|
|
if (!tmp5) {
|
|
if (!tmp6) {
|
|
if (!tmp7) {
|
|
if (tmp9) {
|
|
self._activeItem = _getFirstItemResult;
|
|
self._previousFirstItem = _getFirstItemResult;
|
|
self._snapToItem(_getFirstItemResult, false, true, false, false);
|
|
}
|
|
tmp9 = _getFirstItemResult !== self._previousFirstItem && _getFirstItemResult !== self._activeItem;
|
|
}
|
|
if (self.props.onScroll !== sliderWidth.onScroll) {
|
|
self._setScrollHandler(self.props);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
self._activeItem = _activeItem;
|
|
self._previousItemsLength = _getCustomDataLengthResult;
|
|
const result = self._initPositionsAndInterpolators(self.props);
|
|
if (self._previousItemsLength > _getCustomDataLengthResult) {
|
|
const result1 = self._hackActiveSlideAnimation(_activeItem, null, true);
|
|
}
|
|
if (!tmp4) {
|
|
tmp4 = tmp5;
|
|
}
|
|
if (!tmp4) {
|
|
tmp4 = tmp6;
|
|
}
|
|
if (!tmp4) {
|
|
tmp4 = tmp7;
|
|
}
|
|
if (tmp4) {
|
|
self._snapToItem(_activeItem, false, false, false, false);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "componentWillUnmount",
|
|
value: function componentWillUnmount() {
|
|
this._mounted = false;
|
|
this.stopAutoplay();
|
|
clearTimeout(this._apparitionTimeout);
|
|
clearTimeout(this._hackSlideAnimationTimeout);
|
|
clearTimeout(this._enableAutoplayTimeout);
|
|
clearTimeout(this._autoplayTimeout);
|
|
clearTimeout(this._snapNoMomentumTimeout);
|
|
clearTimeout(this._edgeItemTimeout);
|
|
clearTimeout(this._lockScrollTimeout);
|
|
}
|
|
},
|
|
{
|
|
key: "realIndex",
|
|
get() {
|
|
return this._activeItem;
|
|
}
|
|
},
|
|
{
|
|
key: "currentIndex",
|
|
get() {
|
|
return this._getDataIndex(this._activeItem);
|
|
}
|
|
},
|
|
{
|
|
key: "currentScrollPosition",
|
|
get() {
|
|
return this._currentContentOffset;
|
|
}
|
|
},
|
|
{
|
|
key: "_setScrollHandler",
|
|
value: function _setScrollHandler(props) {
|
|
const self = this;
|
|
let obj = { listener: this._onScroll, useNativeDriver: true };
|
|
let obj1 = Animated;
|
|
const value = new Animated.Value(0);
|
|
this._scrollPos = value;
|
|
obj = { nativeEvent: null };
|
|
obj = { contentOffset: null };
|
|
if (props.vertical) {
|
|
obj1 = { y: null };
|
|
obj1[0] = self._scrollPos;
|
|
obj[0] = obj1;
|
|
obj[0] = obj;
|
|
const items = [obj];
|
|
let items1 = items;
|
|
} else {
|
|
const obj2 = { x: null };
|
|
obj2[0] = self._scrollPos;
|
|
obj[0] = obj2;
|
|
obj[0] = obj;
|
|
items1 = [obj];
|
|
}
|
|
if (props.onScroll) {
|
|
const _Array = Array;
|
|
if (Array.isArray(props.onScroll._argMapping)) {
|
|
items1.pop();
|
|
const first = callback(props.onScroll._argMapping, 1)[0];
|
|
let contentOffset = first;
|
|
if (first) {
|
|
contentOffset = first.nativeEvent;
|
|
}
|
|
if (contentOffset) {
|
|
contentOffset = first.nativeEvent.contentOffset;
|
|
}
|
|
if (contentOffset) {
|
|
self._scrollPos = first.nativeEvent.contentOffset.x || first.nativeEvent.contentOffset.y || self._scrollPos;
|
|
}
|
|
const push = items1.push;
|
|
const items2 = [];
|
|
HermesBuiltin.arraySpread(props.onScroll._argMapping, 0);
|
|
HermesBuiltin.apply(items2, items1);
|
|
}
|
|
}
|
|
self._onScrollHandler = obj1.event(items1, obj);
|
|
}
|
|
},
|
|
{
|
|
key: "_needsScrollView",
|
|
value: function _needsScrollView() {
|
|
const self = this;
|
|
let useScrollView = this.props.useScrollView;
|
|
if (!useScrollView) {
|
|
useScrollView = !animatedComponent;
|
|
}
|
|
if (!useScrollView) {
|
|
useScrollView = self._shouldUseStackLayout();
|
|
}
|
|
if (!useScrollView) {
|
|
useScrollView = self._shouldUseTinderLayout();
|
|
}
|
|
return useScrollView;
|
|
}
|
|
},
|
|
{
|
|
key: "_needsRTLAdaptations",
|
|
value: function _needsRTLAdaptations() {
|
|
let tmp = isRTL;
|
|
if (isRTL) {
|
|
tmp = !this.props.vertical;
|
|
}
|
|
return tmp;
|
|
}
|
|
},
|
|
{
|
|
key: "_canLockScroll",
|
|
value: function _canLockScroll() {
|
|
let lockScrollWhileSnapping;
|
|
let scrollEnabled;
|
|
const props = this.props;
|
|
({ scrollEnabled, lockScrollWhileSnapping } = props);
|
|
if (scrollEnabled) {
|
|
scrollEnabled = !props.enableMomentum;
|
|
}
|
|
if (scrollEnabled) {
|
|
scrollEnabled = lockScrollWhileSnapping;
|
|
}
|
|
return scrollEnabled;
|
|
}
|
|
},
|
|
{
|
|
key: "_enableLoop",
|
|
value: function _enableLoop() {
|
|
const props = this.props;
|
|
const data = props.data;
|
|
let tmp = props.enableSnap && props.loop && data && data.length;
|
|
if (tmp) {
|
|
tmp = data.length > 1;
|
|
}
|
|
return tmp;
|
|
}
|
|
},
|
|
{
|
|
key: "_shouldAnimateSlides",
|
|
value: function _shouldAnimateSlides(props) {
|
|
let scrollInterpolator;
|
|
let slideInterpolatedStyle;
|
|
const self = this;
|
|
if (props === undefined) {
|
|
props = self.props;
|
|
}
|
|
let result = props.inactiveSlideOpacity < 1;
|
|
({ scrollInterpolator, slideInterpolatedStyle } = props);
|
|
if (!result) {
|
|
result = props.inactiveSlideScale < 1;
|
|
}
|
|
if (!result) {
|
|
result = scrollInterpolator;
|
|
}
|
|
if (!result) {
|
|
result = slideInterpolatedStyle;
|
|
}
|
|
if (!result) {
|
|
result = self._shouldUseShiftLayout();
|
|
}
|
|
if (!result) {
|
|
result = self._shouldUseStackLayout();
|
|
}
|
|
if (!result) {
|
|
result = self._shouldUseTinderLayout();
|
|
}
|
|
return result;
|
|
}
|
|
},
|
|
{
|
|
key: "_shouldUseCustomAnimation",
|
|
value: function _shouldUseCustomAnimation() {
|
|
const self = this;
|
|
return this.props.activeAnimationOptions && !self._shouldUseStackLayout() && !self._shouldUseTinderLayout();
|
|
}
|
|
},
|
|
{
|
|
key: "_shouldUseShiftLayout",
|
|
value: function _shouldUseShiftLayout() {
|
|
let tmp2 = "default" === this.props.layout;
|
|
if (tmp2) {
|
|
tmp2 = 0 !== tmp;
|
|
}
|
|
return tmp2;
|
|
}
|
|
},
|
|
{
|
|
key: "_shouldUseStackLayout",
|
|
value: function _shouldUseStackLayout() {
|
|
return "stack" === this.props.layout;
|
|
}
|
|
},
|
|
{
|
|
key: "_shouldUseTinderLayout",
|
|
value: function _shouldUseTinderLayout() {
|
|
return "tinder" === this.props.layout;
|
|
}
|
|
},
|
|
{
|
|
key: "_getCustomData",
|
|
value: function _getCustomData(props) {
|
|
let data;
|
|
let loopClonesPerSide;
|
|
const self = this;
|
|
if (props === undefined) {
|
|
props = self.props;
|
|
}
|
|
({ data, loopClonesPerSide } = props);
|
|
let length = data;
|
|
if (data) {
|
|
length = data.length;
|
|
}
|
|
if (length) {
|
|
if (self._enableLoop()) {
|
|
if (loopClonesPerSide > length) {
|
|
const items = [];
|
|
const items1 = [];
|
|
const _Math = Math;
|
|
const rounded = Math.floor(loopClonesPerSide / length);
|
|
const result = loopClonesPerSide % length;
|
|
for (let num4 = 0; num4 < rounded; num4 = num4 + 1) {
|
|
let push = items.push;
|
|
let items2 = [];
|
|
let tmp6 = items2;
|
|
let tmp7 = data;
|
|
let num5 = 0;
|
|
let arraySpreadResult = HermesBuiltin.arraySpread(data, 0);
|
|
let tmp9 = push;
|
|
let tmp10 = items2;
|
|
let tmp11 = items;
|
|
let applyResult = HermesBuiltin.apply(items2, items);
|
|
let push2 = items1.push;
|
|
let items3 = [];
|
|
let tmp13 = items3;
|
|
let tmp14 = data;
|
|
let num6 = 0;
|
|
arraySpreadResult = HermesBuiltin.arraySpread(data, 0);
|
|
let tmp16 = push2;
|
|
let tmp17 = items3;
|
|
let tmp18 = items1;
|
|
let applyResult1 = HermesBuiltin.apply(items3, items1);
|
|
}
|
|
const unshift = items.unshift;
|
|
const items4 = [];
|
|
HermesBuiltin.arraySpread(data.slice(-result), 0);
|
|
HermesBuiltin.apply(items4, items);
|
|
const push3 = items1.push;
|
|
const items5 = [];
|
|
HermesBuiltin.arraySpread(data.slice(0, result), 0);
|
|
HermesBuiltin.apply(items5, items1);
|
|
let substr1 = items1;
|
|
let obj = items;
|
|
} else {
|
|
const substr = data.slice(-loopClonesPerSide);
|
|
substr1 = data.slice(0, loopClonesPerSide);
|
|
obj = substr;
|
|
}
|
|
return obj.concat(data, substr1);
|
|
} else {
|
|
return data;
|
|
}
|
|
} else {
|
|
return [];
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "_getCustomDataLength",
|
|
value: function _getCustomDataLength(props) {
|
|
const self = this;
|
|
if (props === undefined) {
|
|
props = self.props;
|
|
}
|
|
const data = props.data;
|
|
let length = data;
|
|
if (data) {
|
|
length = data.length;
|
|
}
|
|
let num = 0;
|
|
if (length) {
|
|
let sum = length;
|
|
if (self._enableLoop()) {
|
|
sum = length + 2 * props.loopClonesPerSide;
|
|
}
|
|
num = sum;
|
|
}
|
|
return num;
|
|
}
|
|
},
|
|
{
|
|
key: "_getCustomIndex",
|
|
value: function _getCustomIndex(_activeItem, props) {
|
|
const self = this;
|
|
if (props === undefined) {
|
|
props = self.props;
|
|
}
|
|
const _getCustomDataLengthResult = self._getCustomDataLength(props);
|
|
let num = 0;
|
|
if (_getCustomDataLengthResult) {
|
|
if (_activeItem) {
|
|
let diff = _activeItem;
|
|
if (self._needsRTLAdaptations()) {
|
|
diff = _getCustomDataLengthResult - _activeItem - 1;
|
|
}
|
|
num = diff;
|
|
} else {
|
|
num = 0;
|
|
}
|
|
}
|
|
return num;
|
|
}
|
|
},
|
|
{
|
|
key: "_getDataIndex",
|
|
value: function _getDataIndex(_getActiveItemResult) {
|
|
let data;
|
|
let loopClonesPerSide;
|
|
const self = this;
|
|
({ data, loopClonesPerSide } = this.props);
|
|
let length = data;
|
|
if (data) {
|
|
length = data.length;
|
|
}
|
|
if (self._enableLoop()) {
|
|
if (length) {
|
|
if (_getActiveItemResult >= length + loopClonesPerSide) {
|
|
if (loopClonesPerSide > length) {
|
|
let result = (_getActiveItemResult - loopClonesPerSide) % length;
|
|
} else {
|
|
result = _getActiveItemResult - length - loopClonesPerSide;
|
|
}
|
|
return result;
|
|
} else if (_getActiveItemResult < loopClonesPerSide) {
|
|
if (loopClonesPerSide > length) {
|
|
const items = [];
|
|
const _Math = Math;
|
|
const rounded = Math.floor(loopClonesPerSide / length);
|
|
let num3 = 0;
|
|
const result1 = loopClonesPerSide % length;
|
|
if (0 < length) {
|
|
do {
|
|
let arr = items.push(num3);
|
|
num3 = num3 + 1;
|
|
} while (num3 < length);
|
|
}
|
|
const items1 = [];
|
|
for (let num4 = 0; num4 < rounded; num4 = num4 + 1) {
|
|
let push = items1.push;
|
|
let items2 = [];
|
|
let tmp5 = items2;
|
|
let tmp6 = items;
|
|
let num5 = 0;
|
|
let arraySpreadResult = HermesBuiltin.arraySpread(items, 0);
|
|
let tmp8 = push;
|
|
let tmp9 = items2;
|
|
let tmp10 = items1;
|
|
let applyResult = HermesBuiltin.apply(items2, items1);
|
|
}
|
|
const unshift = items1.unshift;
|
|
const items3 = [];
|
|
HermesBuiltin.arraySpread(items.slice(-result1), 0);
|
|
HermesBuiltin.apply(items3, items1);
|
|
return items1[_getActiveItemResult];
|
|
} else {
|
|
return _getActiveItemResult + length - loopClonesPerSide;
|
|
}
|
|
} else {
|
|
return _getActiveItemResult - loopClonesPerSide;
|
|
}
|
|
}
|
|
}
|
|
return _getActiveItemResult;
|
|
}
|
|
},
|
|
{
|
|
key: "_getPositionIndex",
|
|
value: function _getPositionIndex(closure_1) {
|
|
const props = this.props;
|
|
let sum = closure_1;
|
|
if (props.loop) {
|
|
sum = closure_1 + props.loopClonesPerSide;
|
|
}
|
|
return sum;
|
|
}
|
|
},
|
|
{
|
|
key: "_getFirstItem",
|
|
value: function _getFirstItem(firstItem, props) {
|
|
const self = this;
|
|
if (props === undefined) {
|
|
props = self.props;
|
|
}
|
|
const _getCustomDataLengthResult = self._getCustomDataLength(props);
|
|
let num = 0;
|
|
if (_getCustomDataLengthResult) {
|
|
num = 0;
|
|
if (firstItem <= _getCustomDataLengthResult - 1) {
|
|
num = 0;
|
|
if (firstItem >= 0) {
|
|
let sum = firstItem;
|
|
if (self._enableLoop()) {
|
|
sum = firstItem + props.loopClonesPerSide;
|
|
}
|
|
num = sum;
|
|
}
|
|
}
|
|
}
|
|
return num;
|
|
}
|
|
},
|
|
{
|
|
key: "_getWrappedRef",
|
|
value: function _getWrappedRef() {
|
|
const self = this;
|
|
if (this._carouselRef) {
|
|
if (!self._needsScrollView()) {
|
|
if (!self._needsScrollView()) {
|
|
return self._carouselRef;
|
|
}
|
|
}
|
|
}
|
|
let node = self._carouselRef && self._carouselRef.getNode;
|
|
if (node) {
|
|
const _carouselRef = self._carouselRef;
|
|
node = _carouselRef.getNode();
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "_getScrollEnabled",
|
|
value: function _getScrollEnabled() {
|
|
return this._scrollEnabled;
|
|
}
|
|
},
|
|
{
|
|
key: "_setScrollEnabled",
|
|
value: function _setScrollEnabled(scrollEnabled) {
|
|
let flag = scrollEnabled;
|
|
if (scrollEnabled === undefined) {
|
|
flag = true;
|
|
}
|
|
const _getWrappedRefResult = this._getWrappedRef();
|
|
let setNativeProps = _getWrappedRefResult;
|
|
if (_getWrappedRefResult) {
|
|
setNativeProps = _getWrappedRefResult.setNativeProps;
|
|
}
|
|
if (setNativeProps) {
|
|
const obj = { scrollEnabled: null };
|
|
obj[0] = flag;
|
|
_getWrappedRefResult.setNativeProps(obj);
|
|
this._scrollEnabled = flag;
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "_getKeyExtractor",
|
|
value: function _getKeyExtractor(item, index) {
|
|
if (this._needsScrollView()) {
|
|
let combined = concat(index);
|
|
} else {
|
|
combined = concat(index);
|
|
}
|
|
return combined;
|
|
}
|
|
},
|
|
{
|
|
key: "_getScrollOffset",
|
|
value: function _getScrollOffset(nativeEvent) {
|
|
let num = nativeEvent;
|
|
if (nativeEvent) {
|
|
num = nativeEvent.nativeEvent;
|
|
}
|
|
if (num) {
|
|
num = nativeEvent.nativeEvent.contentOffset;
|
|
}
|
|
if (num) {
|
|
let str = "x";
|
|
if (this.props.vertical) {
|
|
str = "y";
|
|
}
|
|
num = nativeEvent.nativeEvent.contentOffset[str];
|
|
}
|
|
if (!num) {
|
|
num = 0;
|
|
}
|
|
return num;
|
|
}
|
|
},
|
|
{
|
|
key: "_getContainerInnerMargin",
|
|
value: function _getContainerInnerMargin(arg0) {
|
|
let activeSlideAlignment;
|
|
let itemHeight;
|
|
let itemWidth;
|
|
let sliderHeight;
|
|
let sliderWidth;
|
|
let vertical;
|
|
let flag = arg0;
|
|
if (arg0 === undefined) {
|
|
flag = false;
|
|
}
|
|
({ sliderWidth, sliderHeight, itemWidth, itemHeight, vertical, activeSlideAlignment } = this.props);
|
|
if ("start" !== activeSlideAlignment) {
|
|
if ("end" === activeSlideAlignment) {
|
|
let num = 0;
|
|
}
|
|
if ("end" !== activeSlideAlignment) {
|
|
if (!tmp) {
|
|
if (vertical) {
|
|
let result = (sliderHeight - itemHeight) / 2;
|
|
} else {
|
|
result = (sliderWidth - itemWidth) / 2;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
num = 0;
|
|
}
|
|
return num;
|
|
}
|
|
},
|
|
{
|
|
key: "_getViewportOffset",
|
|
value: function _getViewportOffset() {
|
|
let activeSlideAlignment;
|
|
let itemHeight;
|
|
let itemWidth;
|
|
let sliderHeight;
|
|
let sliderWidth;
|
|
let vertical;
|
|
({ sliderWidth, sliderHeight, itemWidth, itemHeight, vertical, activeSlideAlignment } = this.props);
|
|
if ("start" !== activeSlideAlignment) {
|
|
if ("end" === activeSlideAlignment) {
|
|
let num2 = 2;
|
|
if (vertical) {
|
|
num2 = itemHeight / num2;
|
|
let diff = sliderHeight - num2;
|
|
} else {
|
|
diff = sliderWidth - itemWidth / num2;
|
|
}
|
|
} else {
|
|
return vertical ? sliderHeight / 2 : sliderWidth / 2;
|
|
}
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "_getCenter",
|
|
value: function _getCenter(_currentContentOffset) {
|
|
const sum = _currentContentOffset + this._getViewportOffset();
|
|
return sum - this._getContainerInnerMargin();
|
|
}
|
|
},
|
|
{
|
|
key: "_getActiveItem",
|
|
value: function _getActiveItem(_currentContentOffset) {
|
|
const self = this;
|
|
const props = this.props;
|
|
let swipeThreshold = props.activeSlideOffset;
|
|
const _getCenterResult = this._getCenter(_currentContentOffset);
|
|
if (!swipeThreshold) {
|
|
swipeThreshold = props.swipeThreshold;
|
|
}
|
|
let num = 0;
|
|
if (0 < self._positions.length) {
|
|
while (true) {
|
|
let tmp3 = num;
|
|
if (_getCenterResult + swipeThreshold >= self._positions[num].start) {
|
|
if (_getCenterResult - swipeThreshold <= tmp2) {
|
|
break;
|
|
}
|
|
}
|
|
num = num + 1;
|
|
}
|
|
return num;
|
|
}
|
|
const diff = self._positions.length - 1;
|
|
let num2 = 0;
|
|
if (self._positions[diff]) {
|
|
num2 = 0;
|
|
if (_getCenterResult - swipeThreshold > self._positions[diff].end) {
|
|
num2 = diff;
|
|
}
|
|
}
|
|
return num2;
|
|
}
|
|
},
|
|
{
|
|
key: "_initPositionsAndInterpolators",
|
|
value: function _initPositionsAndInterpolators(props) {
|
|
let c2;
|
|
let data;
|
|
let itemWidth;
|
|
let self = this;
|
|
self = this;
|
|
if (props === undefined) {
|
|
props = self.props;
|
|
}
|
|
c2 = undefined;
|
|
itemWidth = undefined;
|
|
let items;
|
|
({ data, itemWidth, scrollInterpolator: c2 } = props);
|
|
if (props.vertical) {
|
|
itemWidth = props.itemHeight;
|
|
}
|
|
if (data) {
|
|
if (data.length) {
|
|
items = [];
|
|
self._positions = [];
|
|
const item = self._getCustomData(props).forEach((arg0, _activeItem) => {
|
|
let obj = self;
|
|
const _getCustomIndexResult = self._getCustomIndex(_activeItem, props);
|
|
obj = { start: _activeItem * itemWidth, end: _activeItem * itemWidth + itemWidth };
|
|
self._positions[_activeItem] = obj;
|
|
if (self._shouldAnimateSlides(props)) {
|
|
if (obj._shouldUseCustomAnimation()) {
|
|
let num2 = 0;
|
|
if (_getCustomIndexResult === obj._activeItem) {
|
|
num2 = 1;
|
|
}
|
|
let interpolateResult = new outer1_7.Value(num2);
|
|
} else {
|
|
if (_undefined) {
|
|
let result = tmp7(_getCustomIndexResult, tmp);
|
|
} else if (obj._shouldUseStackLayout()) {
|
|
result = items(_undefined[11]).stackScrollInterpolator(_getCustomIndexResult, tmp);
|
|
const obj4 = items(_undefined[11]);
|
|
} else if (obj._shouldUseTinderLayout()) {
|
|
result = items(_undefined[11]).tinderScrollInterpolator(_getCustomIndexResult, tmp);
|
|
const obj3 = items(_undefined[11]);
|
|
}
|
|
let outputRange = result;
|
|
if (result) {
|
|
outputRange = result.inputRange;
|
|
}
|
|
if (outputRange) {
|
|
outputRange = result.outputRange;
|
|
}
|
|
if (!outputRange) {
|
|
result = items(_undefined[11]).defaultScrollInterpolator(_getCustomIndexResult, tmp);
|
|
const obj5 = items(_undefined[11]);
|
|
}
|
|
const _scrollPos = obj._scrollPos;
|
|
obj = {};
|
|
const merged = Object.assign(result);
|
|
obj.extrapolate = "clamp";
|
|
interpolateResult = _scrollPos.interpolate(obj);
|
|
}
|
|
} else {
|
|
interpolateResult = new outer1_7.Value(1);
|
|
}
|
|
items.push(interpolateResult);
|
|
});
|
|
let obj = { interpolators: null };
|
|
obj[0] = items;
|
|
self.setState(obj);
|
|
const _getCustomDataResult = self._getCustomData(props);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "_getSlideAnimation",
|
|
value: function _getSlideAnimation(_activeItem, toValue) {
|
|
let parallel;
|
|
let timing;
|
|
const interpolators = this.state.interpolators;
|
|
const props = this.props;
|
|
let tmp = interpolators;
|
|
if (interpolators) {
|
|
tmp = interpolators[_activeItem];
|
|
}
|
|
if (!tmp) {
|
|
if (0 !== tmp) {
|
|
return null;
|
|
}
|
|
}
|
|
let obj = { isInteraction: false, useNativeDriver: true };
|
|
const merged = Object.assign(props.activeAnimationOptions);
|
|
obj.toValue = toValue;
|
|
obj = {};
|
|
({ parallel, timing } = Animated);
|
|
const merged1 = Object.assign(obj);
|
|
obj.easing = linear.linear;
|
|
const items = [timing(tmp, obj), ];
|
|
obj = {};
|
|
const merged2 = Object.assign(obj);
|
|
items[1] = Animated[props.activeAnimationType](tmp, obj);
|
|
return parallel(items);
|
|
}
|
|
},
|
|
{
|
|
key: "_playCustomSlideAnimation",
|
|
value: function _playCustomSlideAnimation(_activeItem, _getActiveItemResult) {
|
|
const self = this;
|
|
const interpolators = this.state.interpolators;
|
|
const _getCustomDataLengthResult = this._getCustomDataLength();
|
|
const items = [];
|
|
const _getDataIndexResult = this._getDataIndex(this._getCustomIndex(_activeItem));
|
|
if (this._enableLoop()) {
|
|
let num5 = 0;
|
|
if (0 < _getCustomDataLengthResult) {
|
|
while (true) {
|
|
let tmp6 = num5;
|
|
if (self._getDataIndex(num5) === _getDataIndexResult) {
|
|
if (interpolators[num5]) {
|
|
let arr = items.push(self._getSlideAnimation(num5, 0));
|
|
num5 = num5 + 1;
|
|
if (num5 >= _getCustomDataLengthResult) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
let tmp7 = self._getDataIndex(num5) === _getDataIndexResult1 && interpolators[num5];
|
|
if (tmp7) {
|
|
arr = items.push(self._getSlideAnimation(num5, 1));
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (interpolators[_activeItem]) {
|
|
items.push(self._getSlideAnimation(_activeItem, 0));
|
|
}
|
|
if (interpolators[_getActiveItemResult]) {
|
|
items.push(self._getSlideAnimation(_getActiveItemResult, 1));
|
|
}
|
|
}
|
|
_getDataIndexResult1 = this._getDataIndex(this._getCustomIndex(_getActiveItemResult));
|
|
Animated.parallel(items, { stopTogether: false }).start();
|
|
}
|
|
},
|
|
{
|
|
key: "_hackActiveSlideAnimation",
|
|
value: function _hackActiveSlideAnimation(_activeItem, start, arg2) {
|
|
let self = this;
|
|
self = this;
|
|
let flag = arg2;
|
|
if (arg2 === undefined) {
|
|
flag = false;
|
|
}
|
|
let c0;
|
|
const data = self.props.data;
|
|
if (self._mounted) {
|
|
if (self._carouselRef) {
|
|
if (self._positions[_activeItem]) {
|
|
if (flag) {
|
|
c0 = tmp2;
|
|
if (self._positions[_activeItem] && self._positions[_activeItem].start) {
|
|
let length = data;
|
|
if (data) {
|
|
length = data.length;
|
|
}
|
|
if (start) {
|
|
let str = "start";
|
|
} else {
|
|
str = "end";
|
|
}
|
|
let num3 = 1;
|
|
if ("start" === str) {
|
|
num3 = -1;
|
|
}
|
|
self._scrollTo(tmp2 + num3, false);
|
|
const _clearTimeout = clearTimeout;
|
|
clearTimeout(self._hackSlideAnimationTimeout);
|
|
const _setTimeout = setTimeout;
|
|
self._hackSlideAnimationTimeout = setTimeout(() => {
|
|
self._scrollTo(c0, false);
|
|
}, 50);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "_lockScroll",
|
|
value: function _lockScroll() {
|
|
const self = this;
|
|
clearTimeout(this._lockScrollTimeout);
|
|
this._lockScrollTimeout = setTimeout(() => {
|
|
self._releaseScroll();
|
|
}, this.props.lockScrollTimeoutDuration);
|
|
this._setScrollEnabled(false);
|
|
}
|
|
},
|
|
{
|
|
key: "_releaseScroll",
|
|
value: function _releaseScroll() {
|
|
clearTimeout(this._lockScrollTimeout);
|
|
this._setScrollEnabled(true);
|
|
}
|
|
},
|
|
{
|
|
key: "_repositionScroll",
|
|
value: function _repositionScroll(_getActiveItemResult) {
|
|
let data;
|
|
let loopClonesPerSide;
|
|
const self = this;
|
|
({ data, loopClonesPerSide } = this.props);
|
|
let length = data;
|
|
if (data) {
|
|
length = data.length;
|
|
}
|
|
if (self._enableLoop()) {
|
|
if (length) {
|
|
let _snapToItemResult = _getActiveItemResult;
|
|
if (_snapToItemResult >= length + loopClonesPerSide) {
|
|
let diff = _snapToItemResult - length;
|
|
} else {
|
|
diff = _snapToItemResult;
|
|
if (_snapToItemResult < loopClonesPerSide) {
|
|
diff = _snapToItemResult + length;
|
|
}
|
|
}
|
|
_snapToItemResult = self._snapToItem(diff, false, false, false, false);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "_scrollTo",
|
|
value: function _scrollTo(_scrollOffsetRef, flag) {
|
|
if (flag === undefined) {
|
|
flag = true;
|
|
}
|
|
const self = this;
|
|
const vertical = this.props.vertical;
|
|
const _getWrappedRefResult = this._getWrappedRef();
|
|
if (this._mounted) {
|
|
if (_getWrappedRefResult) {
|
|
if (self._needsScrollView()) {
|
|
let num = 0;
|
|
if (!vertical) {
|
|
num = _scrollOffsetRef;
|
|
}
|
|
let obj = { x: null, y: null };
|
|
obj[0] = num;
|
|
let num2 = 0;
|
|
if (vertical) {
|
|
num2 = _scrollOffsetRef;
|
|
}
|
|
obj[1] = num2;
|
|
} else {
|
|
obj = { offset: null };
|
|
obj[0] = _scrollOffsetRef;
|
|
}
|
|
const obj1 = {};
|
|
const merged = Object.assign(obj);
|
|
obj1.animated = flag;
|
|
if (self._needsScrollView()) {
|
|
_getWrappedRefResult.scrollTo(obj1);
|
|
} else {
|
|
_getWrappedRefResult.scrollToOffset(obj1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "_onScroll",
|
|
value: function _onScroll(closure_0) {
|
|
let callbackOffsetMargin;
|
|
let enableMomentum;
|
|
let onScroll;
|
|
const self = this;
|
|
({ callbackOffsetMargin, onScroll, enableMomentum } = this.props);
|
|
if (closure_0) {
|
|
let _currentContentOffset = self._getScrollOffset(closure_0);
|
|
} else {
|
|
_currentContentOffset = self._currentContentOffset;
|
|
}
|
|
const _getActiveItemResult = self._getActiveItem(_currentContentOffset);
|
|
let _canFireCallback = _currentContentOffset >= self._scrollOffsetRef - callbackOffsetMargin;
|
|
if (_canFireCallback) {
|
|
_canFireCallback = _currentContentOffset <= self._scrollOffsetRef + callbackOffsetMargin;
|
|
}
|
|
self._currentContentOffset = _currentContentOffset;
|
|
self._onScrollTriggered = true;
|
|
self._lastScrollDate = Date.now();
|
|
if (tmp2) {
|
|
const result = self._playCustomSlideAnimation(self._activeItem, _getActiveItemResult);
|
|
}
|
|
if (enableMomentum) {
|
|
const _clearTimeout = clearTimeout;
|
|
clearTimeout(self._snapNoMomentumTimeout);
|
|
if (self._activeItem !== _getActiveItemResult) {
|
|
self._activeItem = _getActiveItemResult;
|
|
}
|
|
if (tmp4) {
|
|
if (self._canFireBeforeCallback) {
|
|
self._onBeforeSnap(self._getDataIndex(_getActiveItemResult));
|
|
}
|
|
if (_canFireCallback) {
|
|
_canFireCallback = self._canFireCallback;
|
|
}
|
|
if (_canFireCallback) {
|
|
self._onSnap(self._getDataIndex(_getActiveItemResult));
|
|
}
|
|
}
|
|
} else {
|
|
if (tmp5) {
|
|
if (self._canFireBeforeCallback) {
|
|
self._onBeforeSnap(self._getDataIndex(_getActiveItemResult));
|
|
}
|
|
if (_canFireCallback) {
|
|
self._activeItem = _getActiveItemResult;
|
|
if (self._canLockScroll()) {
|
|
self._releaseScroll();
|
|
}
|
|
if (self._canFireCallback) {
|
|
self._onSnap(self._getDataIndex(_getActiveItemResult));
|
|
}
|
|
}
|
|
}
|
|
tmp5 = self._activeItem !== _getActiveItemResult && tmp4;
|
|
}
|
|
if (tmp12) {
|
|
self._repositionScroll(_getActiveItemResult);
|
|
}
|
|
let tmp14 = typeof onScroll === "fileFinishedImporting";
|
|
if (typeof onScroll !== "disabledUntil") {
|
|
tmp14 = closure_0;
|
|
}
|
|
if (tmp14) {
|
|
onScroll(closure_0);
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "_onStartShouldSetResponderCapture",
|
|
value: function _onStartShouldSetResponderCapture(arg0) {
|
|
const self = this;
|
|
const onStartShouldSetResponderCapture = this.props.onStartShouldSetResponderCapture;
|
|
if (onStartShouldSetResponderCapture) {
|
|
const result = onStartShouldSetResponderCapture(arg0);
|
|
}
|
|
return self._getScrollEnabled();
|
|
}
|
|
},
|
|
{
|
|
key: "_onTouchStart",
|
|
value: function _onTouchStart() {
|
|
const self = this;
|
|
const onTouchStart = this.props.onTouchStart;
|
|
if (tmp) {
|
|
self.pauseAutoPlay();
|
|
}
|
|
if (onTouchStart) {
|
|
onTouchStart();
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "_onTouchEnd",
|
|
value: function _onTouchEnd() {
|
|
const self = this;
|
|
const onTouchEnd = this.props.onTouchEnd;
|
|
if (tmp) {
|
|
self.startAutoplay();
|
|
}
|
|
if (onTouchEnd) {
|
|
onTouchEnd();
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "_onScrollBeginDrag",
|
|
value: function _onScrollBeginDrag(closure_0) {
|
|
const self = this;
|
|
const onScrollBeginDrag = this.props.onScrollBeginDrag;
|
|
if (this._getScrollEnabled()) {
|
|
self._scrollStartOffset = self._getScrollOffset(closure_0);
|
|
self._scrollStartActive = self._getActiveItem(self._scrollStartOffset);
|
|
self._ignoreNextMomentum = false;
|
|
if (onScrollBeginDrag) {
|
|
onScrollBeginDrag(closure_0);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "_onScrollEndDrag",
|
|
value: function _onScrollEndDrag(closure_0) {
|
|
const self = this;
|
|
const onScrollEndDrag = this.props.onScrollEndDrag;
|
|
if (tmp) {
|
|
self._onScrollEnd();
|
|
}
|
|
if (onScrollEndDrag) {
|
|
onScrollEndDrag(closure_0);
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "_onMomentumScrollEnd",
|
|
value: function _onMomentumScrollEnd(closure_0) {
|
|
const self = this;
|
|
const onMomentumScrollEnd = this.props.onMomentumScrollEnd;
|
|
if (tmp) {
|
|
self._onScrollEnd();
|
|
}
|
|
if (onMomentumScrollEnd) {
|
|
onMomentumScrollEnd(closure_0);
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "_onScrollEnd",
|
|
value: function _onScrollEnd(arg0) {
|
|
let self = this;
|
|
self = this;
|
|
if (this._ignoreNextMomentum) {
|
|
self._ignoreNextMomentum = false;
|
|
} else if (self._currentContentOffset !== self._scrollEndOffset) {
|
|
self._scrollEndOffset = self._currentContentOffset;
|
|
self._scrollEndActive = self._getActiveItem(self._scrollEndOffset);
|
|
if (tmp2) {
|
|
self._snapScroll(self._scrollEndOffset - self._scrollStartOffset);
|
|
}
|
|
if (tmp4) {
|
|
const _clearTimeout = clearTimeout;
|
|
clearTimeout(self._enableAutoplayTimeout);
|
|
const _setTimeout = setTimeout;
|
|
self._enableAutoplayTimeout = setTimeout(() => {
|
|
self.startAutoplay();
|
|
}, tmp + 50);
|
|
}
|
|
tmp4 = self._autoplay && !self._autoplaying;
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "_onTouchRelease",
|
|
value: function _onTouchRelease(arg0) {
|
|
|
|
}
|
|
},
|
|
{
|
|
key: "_onLayout",
|
|
value: function _onLayout(arg0) {
|
|
const self = this;
|
|
const onLayout = this.props.onLayout;
|
|
if (this._onLayoutInitDone) {
|
|
const result = self._initPositionsAndInterpolators();
|
|
self._snapToItem(self._activeItem, false, false, false, false);
|
|
} else {
|
|
self._onLayoutInitDone = true;
|
|
}
|
|
if (onLayout) {
|
|
onLayout(arg0);
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "_snapScroll",
|
|
value: function _snapScroll(arg0) {
|
|
const self = this;
|
|
const swipeThreshold = this.props.swipeThreshold;
|
|
if (!this._scrollEndActive) {
|
|
const _scrollEndActive = self._scrollEndActive;
|
|
}
|
|
if (self._scrollStartActive !== self._scrollEndActive) {
|
|
self._snapToItem(self._scrollEndActive);
|
|
} else if (arg0 > 0) {
|
|
if (arg0 > swipeThreshold) {
|
|
self._snapToItem(self._scrollStartActive + 1);
|
|
} else {
|
|
self._snapToItem(self._scrollEndActive);
|
|
}
|
|
} else {
|
|
if (arg0 < 0) {
|
|
if (arg0 < -swipeThreshold) {
|
|
self._snapToItem(self._scrollStartActive - 1);
|
|
}
|
|
}
|
|
self._snapToItem(self._scrollEndActive);
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "_snapToItem",
|
|
value: function _snapToItem(_scrollEndActive, flag, flag2, arg3, arg4) {
|
|
let enableMomentum;
|
|
let onBeforeSnapToItem;
|
|
let onSnapToItem;
|
|
let self = this;
|
|
self = this;
|
|
let num = _scrollEndActive;
|
|
let c1 = _scrollEndActive;
|
|
if (flag === undefined) {
|
|
flag = true;
|
|
}
|
|
if (flag2 === undefined) {
|
|
flag2 = true;
|
|
}
|
|
let flag3 = arg3;
|
|
if (arg3 === undefined) {
|
|
flag3 = false;
|
|
}
|
|
let flag4 = arg4;
|
|
if (arg4 === undefined) {
|
|
flag4 = true;
|
|
}
|
|
({ enableMomentum, onSnapToItem, onBeforeSnapToItem } = self.props);
|
|
const _getCustomDataLengthResult = self._getCustomDataLength();
|
|
let _getWrappedRefResult = _getCustomDataLengthResult;
|
|
if (_getCustomDataLengthResult) {
|
|
_getWrappedRefResult = self._getWrappedRef();
|
|
}
|
|
if (_getWrappedRefResult) {
|
|
if (num) {
|
|
if (num >= 0) {
|
|
if (tmp3) {
|
|
const diff = _getCustomDataLengthResult - 1;
|
|
c1 = diff;
|
|
num = diff;
|
|
}
|
|
tmp3 = _getCustomDataLengthResult > 0 && num >= _getCustomDataLengthResult;
|
|
}
|
|
if (num !== self._previousActiveItem) {
|
|
self._previousActiveItem = num;
|
|
if (flag4) {
|
|
flag4 = self._canLockScroll();
|
|
}
|
|
if (flag4) {
|
|
self._lockScroll();
|
|
}
|
|
if (flag2) {
|
|
if (onBeforeSnapToItem) {
|
|
self._canFireBeforeCallback = true;
|
|
}
|
|
if (onSnapToItem) {
|
|
self._canFireCallback = true;
|
|
}
|
|
}
|
|
}
|
|
self._itemToSnapTo = num;
|
|
self._scrollOffsetRef = self._positions[num] && self._positions[num].start;
|
|
self._onScrollTriggered = false;
|
|
let _scrollOffsetRef = self._scrollOffsetRef;
|
|
if (!_scrollOffsetRef) {
|
|
_scrollOffsetRef = 0 === self._scrollOffsetRef;
|
|
}
|
|
if (_scrollOffsetRef) {
|
|
self._scrollTo(self._scrollOffsetRef, flag);
|
|
self._scrollEndOffset = self._currentContentOffset;
|
|
if (enableMomentum) {
|
|
if (!flag3) {
|
|
self._ignoreNextMomentum = true;
|
|
}
|
|
let tmp7 = 0 !== num;
|
|
if (tmp7) {
|
|
tmp7 = num !== _getCustomDataLengthResult - 1;
|
|
}
|
|
if (!tmp7) {
|
|
const _clearTimeout = clearTimeout;
|
|
clearTimeout(self._edgeItemTimeout);
|
|
const _setTimeout = setTimeout;
|
|
self._edgeItemTimeout = setTimeout(() => {
|
|
let _onScrollTriggered = flag3;
|
|
if (!flag3) {
|
|
_onScrollTriggered = c1 !== self._activeItem;
|
|
}
|
|
if (!_onScrollTriggered) {
|
|
_onScrollTriggered = self._onScrollTriggered;
|
|
}
|
|
if (!_onScrollTriggered) {
|
|
self._onScroll();
|
|
}
|
|
}, 250);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
c1 = 0;
|
|
num = 0;
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "_onBeforeSnap",
|
|
value: function _onBeforeSnap(self) {
|
|
const onBeforeSnapToItem = this.props.onBeforeSnapToItem;
|
|
if (this._carouselRef) {
|
|
tmp._canFireBeforeCallback = false;
|
|
if (onBeforeSnapToItem) {
|
|
onBeforeSnapToItem(self);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "_onSnap",
|
|
value: function _onSnap(self) {
|
|
const onSnapToItem = this.props.onSnapToItem;
|
|
if (this._carouselRef) {
|
|
tmp._canFireCallback = false;
|
|
if (onSnapToItem) {
|
|
onSnapToItem(self);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "startAutoplay",
|
|
value: function startAutoplay() {
|
|
let self = this;
|
|
self = this;
|
|
const autoplayInterval = this.props.autoplayInterval;
|
|
this._autoplay = true;
|
|
if (!this._autoplaying) {
|
|
const _clearTimeout = clearTimeout;
|
|
clearTimeout(self._autoplayTimeout);
|
|
const _setTimeout = setTimeout;
|
|
self._autoplayTimeout = setTimeout(() => {
|
|
self._autoplaying = true;
|
|
self._autoplayInterval = setInterval(() => {
|
|
if (_autoplaying._autoplaying) {
|
|
_autoplaying.snapToNext();
|
|
}
|
|
}, autoplayInterval);
|
|
}, tmp);
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "pauseAutoPlay",
|
|
value: function pauseAutoPlay() {
|
|
this._autoplaying = false;
|
|
clearTimeout(this._autoplayTimeout);
|
|
clearTimeout(this._enableAutoplayTimeout);
|
|
clearInterval(this._autoplayInterval);
|
|
}
|
|
},
|
|
{
|
|
key: "stopAutoplay",
|
|
value: function stopAutoplay() {
|
|
this._autoplay = false;
|
|
this.pauseAutoPlay();
|
|
}
|
|
},
|
|
{
|
|
key: "snapToItem",
|
|
value: function snapToItem(rounded, flag, flag2) {
|
|
if (flag === undefined) {
|
|
flag = true;
|
|
}
|
|
if (flag2 === undefined) {
|
|
flag2 = true;
|
|
}
|
|
let num = rounded;
|
|
let tmp = !rounded;
|
|
if (rounded) {
|
|
tmp = num < 0;
|
|
}
|
|
if (tmp) {
|
|
num = 0;
|
|
}
|
|
const self = this;
|
|
const _getPositionIndexResult = this._getPositionIndex(num);
|
|
if (_getPositionIndexResult !== this._activeItem) {
|
|
self._snapToItem(_getPositionIndexResult, flag, flag2);
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "snapToNext",
|
|
value: function snapToNext(flag, flag2) {
|
|
if (flag === undefined) {
|
|
flag = true;
|
|
}
|
|
if (flag2 === undefined) {
|
|
flag2 = true;
|
|
}
|
|
const self = this;
|
|
let num = this._activeItem + 1;
|
|
if (num > this._getCustomDataLength() - 1) {
|
|
num = 0;
|
|
}
|
|
self._snapToItem(num, flag, flag2);
|
|
}
|
|
},
|
|
{
|
|
key: "snapToPrev",
|
|
value: function snapToPrev(flag, flag2) {
|
|
if (flag === undefined) {
|
|
flag = true;
|
|
}
|
|
if (flag2 === undefined) {
|
|
flag2 = true;
|
|
}
|
|
const self = this;
|
|
let diff = this._activeItem - 1;
|
|
if (diff < 0) {
|
|
if (self._enableLoop()) {
|
|
diff = tmp - 1;
|
|
}
|
|
}
|
|
self._snapToItem(diff, flag, flag2);
|
|
}
|
|
},
|
|
{
|
|
key: "triggerRenderingHack",
|
|
value: function triggerRenderingHack(arg0) {
|
|
const self = this;
|
|
if (Date.now() - this._lastScrollDate >= 500) {
|
|
const _currentContentOffset = self._currentContentOffset;
|
|
if (_currentContentOffset) {
|
|
let tmp = arg0;
|
|
if (!arg0) {
|
|
let num2 = -1;
|
|
if (0 === _currentContentOffset) {
|
|
num2 = 1;
|
|
}
|
|
tmp = num2;
|
|
}
|
|
self._scrollTo(_currentContentOffset + tmp, false);
|
|
}
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "_getSlideInterpolatedStyle",
|
|
value: function _getSlideInterpolatedStyle(index, interpolate) {
|
|
let layoutCardOffset;
|
|
let slideInterpolatedStyle;
|
|
const self = this;
|
|
({ layoutCardOffset, slideInterpolatedStyle } = this.props);
|
|
if (slideInterpolatedStyle) {
|
|
let result = slideInterpolatedStyle(index, interpolate, self.props);
|
|
} else if (self._shouldUseTinderLayout()) {
|
|
const obj3 = Carousel(13247);
|
|
result = obj3.tinderAnimatedStyles(index, interpolate, self.props, layoutCardOffset);
|
|
} else if (self._shouldUseStackLayout()) {
|
|
const obj2 = Carousel(13247);
|
|
result = obj2.stackAnimatedStyles(index, interpolate, self.props, layoutCardOffset);
|
|
} else {
|
|
const result1 = self._shouldUseShiftLayout();
|
|
const obj = Carousel(13247);
|
|
if (result1) {
|
|
result = obj.shiftAnimatedStyles(index, interpolate, self.props);
|
|
} else {
|
|
result = obj.defaultAnimatedStyles(index, interpolate, self.props);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
},
|
|
{
|
|
key: "_renderItem",
|
|
value: function _renderItem(arg0) {
|
|
let hasParallaxImages;
|
|
let index;
|
|
let item;
|
|
let itemHeight;
|
|
let itemWidth;
|
|
let keyExtractor;
|
|
let renderItem;
|
|
let slideStyle;
|
|
let sliderHeight;
|
|
let sliderWidth;
|
|
let vertical;
|
|
const self = this;
|
|
({ item, index } = arg0);
|
|
const interpolators = this.state.interpolators;
|
|
const props = this.props;
|
|
({ itemWidth, itemHeight, keyExtractor, vertical } = props);
|
|
let tmp = interpolators;
|
|
({ hasParallaxImages, renderItem, sliderHeight, sliderWidth, slideStyle } = props);
|
|
if (interpolators) {
|
|
tmp = interpolators[index];
|
|
}
|
|
if (!tmp) {
|
|
if (0 !== tmp) {
|
|
return null;
|
|
}
|
|
}
|
|
const _shouldAnimateSlidesResult = self._shouldAnimateSlides();
|
|
if (_shouldAnimateSlidesResult) {
|
|
let View = Animated.View;
|
|
} else {
|
|
View = closure_9;
|
|
}
|
|
if (_shouldAnimateSlidesResult) {
|
|
let result = self._getSlideInterpolatedStyle(index, tmp);
|
|
} else {
|
|
result = {};
|
|
}
|
|
if (hasParallaxImages) {
|
|
let obj = { scrollPosition: null, carouselRef: null, vertical: null, sliderWidth: null, sliderHeight: null, itemWidth: null, itemHeight: null };
|
|
({ _scrollPos: obj2[0], _carouselRef: obj2[1] } = self);
|
|
obj[2] = vertical;
|
|
obj[3] = sliderWidth;
|
|
obj[4] = sliderHeight;
|
|
obj[5] = itemWidth;
|
|
obj[6] = itemHeight;
|
|
const tmp5 = obj;
|
|
}
|
|
if (vertical) {
|
|
obj = { height: null };
|
|
obj[0] = itemHeight;
|
|
let obj1 = obj;
|
|
} else {
|
|
obj1 = { width: null };
|
|
obj1[0] = itemWidth;
|
|
}
|
|
if (self._needsScrollView()) {
|
|
if (keyExtractor) {
|
|
let keyExtractorResult = keyExtractor(item, index);
|
|
} else {
|
|
keyExtractorResult = self._getKeyExtractor(item, index);
|
|
}
|
|
keyExtractor = { key: null };
|
|
keyExtractor[0] = keyExtractorResult;
|
|
} else {
|
|
const obj2 = {};
|
|
const obj3 = { style: null, pointerEvents: "box-none" };
|
|
const items = [obj1, slideStyle, result];
|
|
obj3[0] = items;
|
|
const merged = Object.assign(obj2);
|
|
const obj4 = { item: null, index: null };
|
|
obj4[0] = item;
|
|
obj4[1] = index;
|
|
obj3.children = renderItem(obj4, tmp5);
|
|
return <View style={null} pointerEvents="box-none" />;
|
|
}
|
|
}
|
|
},
|
|
{
|
|
key: "_getComponentOverridableProps",
|
|
value: function _getComponentOverridableProps() {
|
|
let enableMomentum;
|
|
let loopClonesPerSide;
|
|
const self = this;
|
|
const props = this.props;
|
|
({ enableMomentum, loopClonesPerSide } = props);
|
|
const sum = Math.ceil(props.vertical ? props.sliderHeight / props.itemHeight : props.sliderWidth / props.itemWidth) + 1;
|
|
let num = 2;
|
|
if (self._enableLoop()) {
|
|
num = loopClonesPerSide;
|
|
}
|
|
const result = 2 * num;
|
|
if (self._needsScrollView()) {
|
|
let obj = {};
|
|
} else {
|
|
const sum1 = sum + result;
|
|
const sum2 = 1 + 2 * sum1;
|
|
obj = { initialNumToRender: null, maxToRenderPerBatch: null, windowSize: null };
|
|
obj[0] = sum1;
|
|
obj[1] = sum2;
|
|
obj[2] = sum2;
|
|
}
|
|
let num2 = "fast";
|
|
if (enableMomentum) {
|
|
num2 = 0.9;
|
|
}
|
|
obj = { decelerationRate: num2, showsHorizontalScrollIndicator: false, showsVerticalScrollIndicator: false, overScrollMode: "never", automaticallyAdjustContentInsets: false, directionalLockEnabled: true, pinchGestureEnabled: false, scrollsToTop: false, removeClippedSubviews: !self._needsScrollView(), inverted: self._needsRTLAdaptations() };
|
|
const merged = Object.assign(obj);
|
|
return obj;
|
|
}
|
|
},
|
|
{
|
|
key: "_getComponentStaticProps",
|
|
value: function _getComponentStaticProps() {
|
|
let containerCustomStyle;
|
|
let contentContainerCustomStyle;
|
|
let keyExtractor;
|
|
let sliderHeight;
|
|
let sliderWidth;
|
|
let vertical;
|
|
let self = this;
|
|
self = this;
|
|
const props = this.props;
|
|
({ containerCustomStyle, contentContainerCustomStyle, keyExtractor, vertical } = props);
|
|
({ sliderWidth, sliderHeight } = props);
|
|
if (!containerCustomStyle) {
|
|
containerCustomStyle = props.style;
|
|
}
|
|
if (!containerCustomStyle) {
|
|
containerCustomStyle = {};
|
|
}
|
|
const items = [containerCustomStyle, this.state.hideCarousel ? { opacity: 0 } : {}, ];
|
|
if (vertical) {
|
|
let obj = { height: null, flexDirection: "column" };
|
|
obj[0] = sliderHeight;
|
|
} else {
|
|
obj = { width: null, flexDirection: null };
|
|
obj[0] = sliderWidth;
|
|
let str = "row";
|
|
if (self._needsRTLAdaptations()) {
|
|
str = "row-reverse";
|
|
}
|
|
obj[1] = str;
|
|
}
|
|
items[2] = obj;
|
|
if (vertical) {
|
|
obj = { paddingTop: null, paddingBottom: null };
|
|
obj[0] = self._getContainerInnerMargin();
|
|
obj[1] = self._getContainerInnerMargin(true);
|
|
let obj1 = obj;
|
|
} else {
|
|
obj1 = { paddingLeft: null, paddingRight: null };
|
|
obj1[0] = self._getContainerInnerMargin();
|
|
obj1[1] = self._getContainerInnerMargin(true);
|
|
}
|
|
const items1 = [obj1, ];
|
|
if (!contentContainerCustomStyle) {
|
|
contentContainerCustomStyle = {};
|
|
}
|
|
items1[1] = contentContainerCustomStyle;
|
|
if (self._needsScrollView()) {
|
|
let obj2 = {};
|
|
} else {
|
|
obj2 = { renderItem: null, numColumns: 1, keyExtractor: null };
|
|
obj2[0] = self._renderItem;
|
|
if (!keyExtractor) {
|
|
keyExtractor = self._getKeyExtractor;
|
|
}
|
|
obj2[2] = keyExtractor;
|
|
}
|
|
const merged = Object.assign(obj2);
|
|
return {
|
|
ref(_carouselRef) {
|
|
self._carouselRef = _carouselRef;
|
|
return _carouselRef;
|
|
},
|
|
data: self._getCustomData(),
|
|
style: items,
|
|
contentContainerStyle: items1,
|
|
horizontal: !vertical,
|
|
scrollEventThrottle: 1,
|
|
onScroll: self._onScrollHandler,
|
|
onScrollBeginDrag: self._onScrollBeginDrag,
|
|
onScrollEndDrag: self._onScrollEndDrag,
|
|
onMomentumScrollEnd: self._onMomentumScrollEnd,
|
|
onResponderRelease: self._onTouchRelease,
|
|
onStartShouldSetResponderCapture: self._onStartShouldSetResponderCapture,
|
|
onTouchStart: self._onTouchStart,
|
|
onTouchEnd: self._onScrollEnd,
|
|
onLayout: self._onLayout
|
|
};
|
|
}
|
|
},
|
|
{
|
|
key: "render",
|
|
value: function render() {
|
|
let self = this;
|
|
self = this;
|
|
const props = this.props;
|
|
let useScrollView = props.useScrollView;
|
|
if (props.data) {
|
|
if (props.renderItem) {
|
|
let obj = {};
|
|
const merged = Object.assign(self._getComponentOverridableProps());
|
|
const merged1 = Object.assign(self.props);
|
|
const merged2 = Object.assign(self._getComponentStaticProps());
|
|
if (typeof useScrollView !== "fileFinishedImporting") {
|
|
useScrollView = closure_13;
|
|
}
|
|
obj = {};
|
|
if (self._needsScrollView()) {
|
|
const merged3 = Object.assign(obj);
|
|
obj.children = self._getCustomData().map((item, index) => self._renderItem({ item, index }));
|
|
let tmp7Result = tmp7(useScrollView, obj);
|
|
const _getCustomDataResult = self._getCustomData();
|
|
} else {
|
|
const merged4 = Object.assign(obj);
|
|
tmp7Result = tmp7(animatedComponent, obj);
|
|
}
|
|
return tmp7Result;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
];
|
|
const importDefaultResultResult = importDefaultResult(Carousel, items);
|
|
obj = { data: require("emptyFunction").array.isRequired, renderItem: require("emptyFunction").func.isRequired, itemWidth: require("emptyFunction").number, itemHeight: require("emptyFunction").number, sliderWidth: require("emptyFunction").number, sliderHeight: require("emptyFunction").number, activeAnimationType: require("emptyFunction").string, activeAnimationOptions: require("emptyFunction").object, activeSlideAlignment: null, activeSlideOffset: null, apparitionDelay: null, autoplay: null, autoplayDelay: null, autoplayInterval: null, callbackOffsetMargin: null, containerCustomStyle: null, contentContainerCustomStyle: null, enableMomentum: null, enableSnap: null, firstItem: null, hasParallaxImages: null, inactiveSlideOpacity: null, inactiveSlideScale: null, inactiveSlideShift: null, layout: null, layoutCardOffset: null, lockScrollTimeoutDuration: null, lockScrollWhileSnapping: null, loop: null, loopClonesPerSide: null, scrollEnabled: null, scrollInterpolator: null, slideInterpolatedStyle: null, slideStyle: null, shouldOptimizeUpdates: null, swipeThreshold: null, useScrollView: null, vertical: null, onBeforeSnapToItem: null, onSnapToItem: null };
|
|
obj[8] = require("emptyFunction").oneOf(["center", "end", "start"]);
|
|
obj[9] = require("emptyFunction").number;
|
|
obj[10] = require("emptyFunction").number;
|
|
obj[11] = require("emptyFunction").bool;
|
|
obj[12] = require("emptyFunction").number;
|
|
obj[13] = require("emptyFunction").number;
|
|
obj[14] = require("emptyFunction").number;
|
|
obj[15] = require("get ColorPropType").ViewPropTypes.style;
|
|
obj[16] = require("get ColorPropType").ViewPropTypes.style;
|
|
obj[17] = require("emptyFunction").bool;
|
|
obj[18] = require("emptyFunction").bool;
|
|
obj[19] = require("emptyFunction").number;
|
|
obj[20] = require("emptyFunction").bool;
|
|
obj[21] = require("emptyFunction").number;
|
|
obj[22] = require("emptyFunction").number;
|
|
obj[23] = require("emptyFunction").number;
|
|
obj[24] = require("emptyFunction").oneOf(["default", "stack", "tinder"]);
|
|
obj[25] = require("emptyFunction").number;
|
|
obj[26] = require("emptyFunction").number;
|
|
obj[27] = require("emptyFunction").bool;
|
|
obj[28] = require("emptyFunction").bool;
|
|
obj[29] = require("emptyFunction").number;
|
|
obj[30] = require("emptyFunction").bool;
|
|
obj[31] = require("emptyFunction").func;
|
|
obj[32] = require("emptyFunction").func;
|
|
obj[33] = require("get ColorPropType").ViewPropTypes.style;
|
|
obj[34] = require("emptyFunction").bool;
|
|
obj[35] = require("emptyFunction").number;
|
|
let items1 = [require("emptyFunction").bool, require("emptyFunction").func];
|
|
obj[36] = require("emptyFunction").oneOfType(items1);
|
|
obj[37] = require("emptyFunction").bool;
|
|
obj[38] = require("emptyFunction").func;
|
|
obj[39] = require("emptyFunction").func;
|
|
importDefaultResultResult.propTypes = obj;
|
|
importDefaultResultResult.defaultProps = { activeAnimationType: "timing", activeAnimationOptions: null, activeSlideAlignment: "center", activeSlideOffset: 20, apparitionDelay: 0, autoplay: false, autoplayDelay: 1000, autoplayInterval: 3000, callbackOffsetMargin: 5, containerCustomStyle: {}, contentContainerCustomStyle: {}, enableMomentum: false, enableSnap: true, firstItem: 0, hasParallaxImages: false, inactiveSlideOpacity: 0.7, inactiveSlideScale: 0.9, inactiveSlideShift: 0, layout: "default", lockScrollTimeoutDuration: 1000, lockScrollWhileSnapping: false, loop: false, loopClonesPerSide: 3, scrollEnabled: true, slideStyle: {}, shouldOptimizeUpdates: true, swipeThreshold: 20, useScrollView: !animatedComponent, vertical: false };
|
|
|
|
export default importDefaultResultResult;
|