629 lines
22 KiB
JavaScript
629 lines
22 KiB
JavaScript
// Module ID: 5495
|
|
// Function ID: 5496
|
|
// Name: RecyclerView
|
|
// Dependencies: [5496, 5502, 19, 17, 21, 5504, 5513, 5514, 5516, 5538, 5543, 5544, 5533, 5536, 5542, 5515, 5545, 5493, 5549, 5546, 5551, 5552]
|
|
|
|
// Module 5495 (RecyclerView)
|
|
import _slicedToArray from "_slicedToArray";
|
|
import _objectWithoutProperties from "_objectWithoutProperties";
|
|
import noop from "CompatView";
|
|
import get_ActivityIndicator from "module_5493";
|
|
import jsxProd from "ViewHolderCollection";
|
|
|
|
let c10;
|
|
let c5;
|
|
let c9;
|
|
let closure_12;
|
|
let closure_14;
|
|
let closure_6;
|
|
let error;
|
|
let forwardRef;
|
|
let map1;
|
|
let metroImportAll;
|
|
let unpackModuleId;
|
|
const require = arg1;
|
|
let closure_2 = ["horizontal", "renderItem", "data", "extraData", "onLoad", "CellRendererComponent", "overrideProps", "refreshing", "onRefresh", "progressViewOffset", "ListEmptyComponent", "ListHeaderComponent", "ListHeaderComponentStyle", "ListFooterComponent", "ListFooterComponentStyle", "ItemSeparatorComponent", "renderScrollComponent", "style", "stickyHeaderIndices", "maintainVisibleContentPosition", "onCommitLayoutEffect", "onChangeStickyIndex", "stickyHeaderConfig", "inverted"];
|
|
({ useCallback: c5, useLayoutEffect: closure_6, useMemo: error, useRef: metroImportAll, useState: c9, useId: c10, forwardRef } = noop);
|
|
({ Animated: unpackModuleId, I18nManager: closure_12 } = get_ActivityIndicator);
|
|
({ jsx: map1, jsxs: closure_14 } = jsxProd);
|
|
class RecyclerViewComponent {
|
|
constructor(arg0, arg1) {
|
|
horizontal = global.horizontal;
|
|
renderItem = global.renderItem;
|
|
data = global.data;
|
|
extraData = global.extraData;
|
|
({ overrideProps, refreshing, onRefresh, progressViewOffset, ListEmptyComponent, ListHeaderComponent, ListHeaderComponentStyle, ListFooterComponent, ListFooterComponentStyle, renderScrollComponent, stickyHeaderIndices } = global);
|
|
maintainVisibleContentPosition = global.maintainVisibleContentPosition;
|
|
useCallback = maintainVisibleContentPosition;
|
|
({ onCommitLayoutEffect, onChangeStickyIndex } = global);
|
|
({ stickyHeaderConfig, inverted } = global);
|
|
({ onLoad, CellRendererComponent, ItemSeparatorComponent, style } = global);
|
|
tmp = stickyHeaderIndices(global, data);
|
|
tmp2 = useState;
|
|
tmp3 = extraData;
|
|
first = extraData(useState(() => {
|
|
const renderTimeTracker = new horizontal(renderItem[5]).RenderTimeTracker();
|
|
return renderTimeTracker;
|
|
}), 1)[0];
|
|
useState = first;
|
|
startTrackingResult = first.startTracking();
|
|
num = undefined;
|
|
if (stickyHeaderConfig != null) {
|
|
num = stickyHeaderConfig.offset;
|
|
}
|
|
if (num == null) {
|
|
num = 0;
|
|
}
|
|
c10 = num;
|
|
flag = undefined;
|
|
if (stickyHeaderConfig != null) {
|
|
flag = stickyHeaderConfig.useNativeDriver;
|
|
}
|
|
if (flag == null) {
|
|
flag = true;
|
|
}
|
|
c11 = flag;
|
|
flag2 = undefined;
|
|
if (stickyHeaderConfig != null) {
|
|
flag2 = stickyHeaderConfig.hideRelatedCell;
|
|
}
|
|
if (flag2 == null) {
|
|
flag2 = false;
|
|
}
|
|
c12 = flag2;
|
|
num2 = undefined;
|
|
if (stickyHeaderConfig != null) {
|
|
num2 = stickyHeaderConfig.zIndex;
|
|
}
|
|
if (num2 == null) {
|
|
num2 = 2;
|
|
}
|
|
c13 = num2;
|
|
invertedTransformStyle = undefined;
|
|
if (inverted) {
|
|
tmp6 = horizontal;
|
|
tmp7 = renderItem;
|
|
obj2 = require("getInvertedTransformStyle");
|
|
invertedTransformStyle = obj2.getInvertedTransformStyle(horizontal);
|
|
}
|
|
tmp8 = inverted(null);
|
|
jsxs = tmp8;
|
|
tmp9 = inverted(null);
|
|
closure_15 = tmp9;
|
|
getInvertedTransformStyle = inverted(null);
|
|
getInvertedTransformStyle = inverted(undefined);
|
|
set = new Set();
|
|
current = inverted(set).current;
|
|
value = new c11.Value(0);
|
|
current2 = inverted(value).current;
|
|
current = current2;
|
|
Value = inverted(null);
|
|
tmp12 = inverted(null);
|
|
closure_21 = tmp12;
|
|
tmp13 = horizontal;
|
|
tmp14 = renderItem;
|
|
obj3 = require("useLayoutState");
|
|
tmp3Result = tmp3(require("_slicedToArray"), 2);
|
|
[r10087, tmp16] = tmp3Result;
|
|
useLayoutState = tmp16;
|
|
tmp3Result1 = tmp3(require("_slicedToArray"), 2);
|
|
[r10091, closure_23] = tmp3Result1;
|
|
tmp3Result2 = tmp3(require("module_4294967295"), 2);
|
|
first1 = tmp3Result2[0];
|
|
closure_24 = first1;
|
|
closure_25 = tmp3Result2[1];
|
|
tmp20 = onChangeStickyIndex;
|
|
tmp21 = onChangeStickyIndex(() => new Map(), []);
|
|
closure_26 = tmp21;
|
|
obj4 = require("useRecyclerViewManager");
|
|
recyclerViewManager = obj4.useRecyclerViewManager(global);
|
|
recyclerViewManager = recyclerViewManager.recyclerViewManager;
|
|
velocityTracker = recyclerViewManager.velocityTracker;
|
|
obj5 = require("useRecyclerViewController");
|
|
recyclerViewController = obj5.useRecyclerViewController(recyclerViewManager, arg1, tmp8, tmp12);
|
|
({ applyOffsetCorrection, computeFirstVisibleIndexForOffsetCorrection } = recyclerViewController);
|
|
closure_30 = computeFirstVisibleIndexForOffsetCorrection;
|
|
({ applyInitialScrollIndex, handlerMethods } = recyclerViewController);
|
|
tmp24 = inverted(null);
|
|
closure_33 = tmp24;
|
|
obj6 = require("useOnLoad");
|
|
onListLoad = obj6.useOnListLoad(recyclerViewManager, onLoad);
|
|
obj7 = require("useBoundDetection");
|
|
checkBounds = obj7.useBoundDetection(recyclerViewManager, tmp8).checkBounds;
|
|
tmp26 = c12.isRTL && horizontal;
|
|
isRTL = tmp26;
|
|
tmp27 = onCommitLayoutEffect(() => {
|
|
if (tmp9.current) {
|
|
if (ref.current) {
|
|
let obj = horizontal(renderItem[12]);
|
|
const size = obj.measureParentSize(tmp.current);
|
|
const size2 = horizontal(renderItem[12]).measureFirstChildLayout(tmp2.current, tmp.current);
|
|
closure_17.current = size;
|
|
const tmp7 = horizontal ? size2.x : size2.y;
|
|
obj = { width: null, height: null };
|
|
obj[0] = horizontal ? size.width : size2.width;
|
|
obj[1] = horizontal ? size2.height : size.height;
|
|
let diff = tmp7;
|
|
if (closure_35) {
|
|
diff = tmp7;
|
|
if (obj3.hasLayout()) {
|
|
diff = tmp7 - obj3.getChildContainerDimensions().width;
|
|
}
|
|
}
|
|
recyclerViewManager.updateLayoutParams(obj, diff);
|
|
const obj2 = horizontal(renderItem[12]);
|
|
}
|
|
}
|
|
});
|
|
tmp28 = onCommitLayoutEffect(() => {
|
|
if (current.size <= 0) {
|
|
const _Array = Array;
|
|
const result = first.hasExceededMaxRendersWithoutCommit();
|
|
if (result) {
|
|
const _console = console;
|
|
console.warn(horizontal(renderItem[13]).WarningMessages.exceededMaxRendersWithoutCommit);
|
|
}
|
|
let num;
|
|
if (data != null) {
|
|
num = data.length;
|
|
}
|
|
if (num == null) {
|
|
num = 0;
|
|
}
|
|
if (recyclerViewManager.modifyChildrenLayout(arr, num)) {
|
|
if (!result) {
|
|
callback2((arg0) => arg0 + 1);
|
|
}
|
|
let hasLayoutResult = horizontal;
|
|
if (horizontal) {
|
|
hasLayoutResult = obj.hasLayout();
|
|
}
|
|
if (hasLayoutResult) {
|
|
hasLayoutResult = obj.getWindowSize().height > 0;
|
|
}
|
|
if (hasLayoutResult) {
|
|
if (recyclerViewContext != null) {
|
|
const result1 = obj2.unmarkChildLayoutAsPending(closure_38);
|
|
}
|
|
obj2 = recyclerViewContext;
|
|
}
|
|
}
|
|
current = tmp24.current;
|
|
if (current != null) {
|
|
current.commitLayout();
|
|
}
|
|
callback3();
|
|
arr = Array.from(closure_26, (arg0) => {
|
|
let tmp;
|
|
let tmp2;
|
|
[tmp, tmp2] = arg0;
|
|
const obj = { index: tmp, dimensions: null };
|
|
obj[1] = outer1_0(outer1_1[12]).measureItemLayout(tmp2.current, closure_27.tryGetLayout(tmp));
|
|
return obj;
|
|
});
|
|
}
|
|
});
|
|
items = [, , , , , ];
|
|
items[0] = checkBounds;
|
|
items[1] = computeFirstVisibleIndexForOffsetCorrection;
|
|
items[2] = horizontal;
|
|
items[3] = tmp26;
|
|
items[4] = recyclerViewManager;
|
|
items[5] = velocityTracker;
|
|
tmp29 = useCallback((nativeEvent) => {
|
|
if (!recyclerViewManager.ignoreScrollEvents) {
|
|
const contentOffset = nativeEvent.nativeEvent.contentOffset;
|
|
const tmp3 = horizontal ? contentOffset.x : contentOffset.y;
|
|
horizontal = tmp3;
|
|
let tmp5 = tmp3;
|
|
if (closure_35) {
|
|
const adjustOffsetForRTLResult = horizontal(renderItem[14]).adjustOffsetForRTL(tmp3, nativeEvent.nativeEvent.contentSize.width, nativeEvent.nativeEvent.layoutMeasurement.width);
|
|
horizontal = adjustOffsetForRTLResult;
|
|
tmp5 = adjustOffsetForRTLResult;
|
|
const obj2 = horizontal(renderItem[14]);
|
|
}
|
|
const _Boolean = Boolean;
|
|
const absoluteLastScrollOffset = obj.getAbsoluteLastScrollOffset();
|
|
const velocity = velocityTracker.computeVelocity(tmp5, absoluteLastScrollOffset, Boolean(horizontal), (arg0, arg1) => {
|
|
if (!outer1_27.ignoreScrollEvents) {
|
|
if (arg1) {
|
|
outer1_30();
|
|
if (obj.isOffsetProjectionEnabled) {
|
|
obj.resetVelocityCompute();
|
|
}
|
|
}
|
|
if (obj.updateScrollOffset(closure_0, arg0)) {
|
|
outer1_23((arg0) => arg0 + 1);
|
|
}
|
|
}
|
|
});
|
|
const current = ref3.current;
|
|
if (current != null) {
|
|
current.reportScrollEvent(nativeEvent.nativeEvent);
|
|
}
|
|
checkBounds();
|
|
if (obj.isInitialScrollComplete) {
|
|
obj.recordInteraction();
|
|
}
|
|
const itemViewability = obj.computeItemViewability();
|
|
const props = obj.props;
|
|
const onScroll = props.onScroll;
|
|
if (onScroll != null) {
|
|
onScroll(nativeEvent);
|
|
}
|
|
const tmp2 = horizontal;
|
|
}
|
|
}, items);
|
|
closure_36 = tmp29;
|
|
tmp13Result = require("context");
|
|
recyclerViewContext = tmp13Result.useRecyclerViewContext();
|
|
closure_37 = recyclerViewContext;
|
|
tmp30 = c10();
|
|
closure_38 = tmp30;
|
|
items1 = [, , , , ];
|
|
items1[0] = handlerMethods;
|
|
items1[1] = recyclerViewContext;
|
|
items1[2] = current;
|
|
items1[3] = recyclerViewManager.isDisposed;
|
|
items1[4] = tmp16;
|
|
tmp20Result = tmp20(() => ({
|
|
layout() {
|
|
callback((arg0) => arg0 + 1);
|
|
},
|
|
getRef() {
|
|
let tmp = null;
|
|
if (!isDisposed.isDisposed) {
|
|
tmp = closure_32;
|
|
}
|
|
return tmp;
|
|
},
|
|
getParentRef() {
|
|
let ref;
|
|
if (closure_37 != null) {
|
|
ref = closure_37.getRef();
|
|
}
|
|
if (ref == null) {
|
|
ref = null;
|
|
}
|
|
return ref;
|
|
},
|
|
getParentScrollViewRef() {
|
|
let scrollViewRef;
|
|
if (closure_37 != null) {
|
|
scrollViewRef = closure_37.getScrollViewRef();
|
|
}
|
|
if (scrollViewRef == null) {
|
|
scrollViewRef = null;
|
|
}
|
|
return scrollViewRef;
|
|
},
|
|
getScrollViewRef() {
|
|
return ref.current;
|
|
},
|
|
markChildLayoutAsPending(arg0) {
|
|
set.add(arg0);
|
|
},
|
|
unmarkChildLayoutAsPending(arg0) {
|
|
if (set.has(arg0)) {
|
|
set.delete(arg0);
|
|
closure_39.layout();
|
|
}
|
|
}
|
|
}), items1);
|
|
f76492 = tmp20Result;
|
|
items2 = [, ];
|
|
items2[0] = tmp20Result;
|
|
items2[1] = recyclerViewManager;
|
|
tmp32 = useCallback((arg0, width) => {
|
|
const size = recyclerViewManager.getLayout(arg0);
|
|
let num = size.maxWidth;
|
|
if (num == null) {
|
|
num = Infinity;
|
|
}
|
|
let num2 = size.minWidth;
|
|
const bound = Math.min(size.width, num);
|
|
if (num2 == null) {
|
|
num2 = 0;
|
|
}
|
|
let num3 = size.maxHeight;
|
|
const bound1 = Math.max(bound, num2);
|
|
if (num3 == null) {
|
|
num3 = Infinity;
|
|
}
|
|
let num4 = size.minHeight;
|
|
const bound2 = Math.min(size.height, num3);
|
|
if (num4 == null) {
|
|
num4 = 0;
|
|
}
|
|
const bound3 = Math.max(bound2, num4);
|
|
let result = horizontal(renderItem[12]).areDimensionsNotEqual(bound1, width.width);
|
|
if (!result) {
|
|
result = horizontal(renderItem[12]).areDimensionsNotEqual(bound3, width.height);
|
|
const tmp5Result = horizontal(renderItem[12]);
|
|
}
|
|
if (result) {
|
|
tmp20Result.layout();
|
|
}
|
|
}, items2);
|
|
tmp13Result1 = require("useSecondaryProps");
|
|
secondaryProps = tmp13Result1.useSecondaryProps(global);
|
|
({ refreshControl, renderHeader, renderFooter, renderEmpty, CompatScrollView, renderStickyHeaderBackdrop } = secondaryProps);
|
|
isFirstLayoutComplete = recyclerViewManager.getIsFirstLayoutComplete();
|
|
tmp35 = !isFirstLayoutComplete;
|
|
if (!isFirstLayoutComplete) {
|
|
tmp35 = recyclerViewManager.getDataLength() > 0;
|
|
}
|
|
if (tmp35) {
|
|
if (recyclerViewContext != null) {
|
|
result = recyclerViewContext.markChildLayoutAsPending(tmp30);
|
|
}
|
|
}
|
|
items3 = [, , , , , , , , , , , , ];
|
|
items3[0] = data;
|
|
items3[1] = stickyHeaderIndices;
|
|
items3[2] = num;
|
|
items3[3] = renderItem;
|
|
items3[4] = current2;
|
|
items3[5] = horizontal;
|
|
items3[6] = recyclerViewManager;
|
|
items3[7] = extraData;
|
|
items3[8] = first1;
|
|
items3[9] = onChangeStickyIndex;
|
|
items3[10] = flag2;
|
|
items3[11] = num2;
|
|
items3[12] = inverted;
|
|
tmp20Result1 = tmp20(() => {
|
|
if (data) {
|
|
if (arr.length > 0) {
|
|
if (stickyHeaderIndices) {
|
|
if (arr2.length > 0) {
|
|
if (horizontal) {
|
|
const _Error = Error;
|
|
const error = new Error(horizontal(renderItem[17]).ErrorMessages.stickyHeadersNotSupportedForHorizontal);
|
|
throw error;
|
|
} else {
|
|
const obj = { stickyHeaderIndices: null, stickyHeaderOffset: null, data: null, renderItem: null, scrollY: null, stickyHeaderRef: null, stickyHeaderZIndex: null, recyclerViewManager: null, extraData: null, inverted: null, onChangeStickyIndex: null };
|
|
obj[0] = arr2;
|
|
obj[1] = num;
|
|
obj[2] = arr;
|
|
obj[3] = renderItem;
|
|
obj[4] = current2;
|
|
obj[5] = closure_20;
|
|
obj[6] = num2;
|
|
obj[7] = recyclerViewManager;
|
|
obj[8] = extraData;
|
|
obj[9] = inverted;
|
|
obj[10] = function onChangeStickyIndex(arg0, items1) {
|
|
if (closure_12) {
|
|
callback(arg0);
|
|
}
|
|
if (closure_7 != null) {
|
|
tmp3(arg0, closure_24);
|
|
}
|
|
};
|
|
return num2(horizontal(renderItem[18]).StickyHeaders, obj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}, items3);
|
|
markChildLayoutAsPending = tmp20Result1;
|
|
items4 = [, , , ];
|
|
items4[0] = tmp29;
|
|
items4[1] = current2;
|
|
items4[2] = tmp20Result1;
|
|
items4[3] = flag;
|
|
tmp20Result2 = tmp20(() => {
|
|
if (closure_40) {
|
|
let obj = { nativeEvent: null };
|
|
obj = { contentOffset: null };
|
|
obj = { y: null };
|
|
obj[0] = current2;
|
|
obj[0] = obj;
|
|
obj[0] = obj;
|
|
const items = [obj];
|
|
const obj1 = { useNativeDriver: null, listener: null };
|
|
obj1[0] = flag;
|
|
obj1[1] = closure_36;
|
|
let eventResult = flag.event(items, obj1);
|
|
} else {
|
|
eventResult = closure_36;
|
|
}
|
|
return eventResult;
|
|
}, items4);
|
|
result1 = recyclerViewManager.shouldMaintainVisibleContentPosition();
|
|
f76495 = result1;
|
|
items5 = [, ];
|
|
items5[0] = maintainVisibleContentPosition;
|
|
items5[1] = result1;
|
|
tmp20Result3 = tmp20(() => {
|
|
if (result1) {
|
|
const obj = {};
|
|
const merged = Object.assign(maintainVisibleContentPosition);
|
|
obj.minIndexForVisible = 0;
|
|
return obj;
|
|
}
|
|
}, items5);
|
|
tmp41 = recyclerViewManager.getDataLength() > 0;
|
|
if (tmp41) {
|
|
flag3 = undefined;
|
|
if (maintainVisibleContentPosition != null) {
|
|
flag3 = maintainVisibleContentPosition.startRenderingFromBottom;
|
|
}
|
|
if (flag3 == null) {
|
|
flag3 = false;
|
|
}
|
|
tmp41 = flag3;
|
|
}
|
|
getDataLength = tmp41;
|
|
items6 = [, ];
|
|
items6[0] = horizontal;
|
|
items6[1] = num;
|
|
tmp20Result4 = tmp20(() => {
|
|
let tmp3;
|
|
if (!horizontal) {
|
|
tmp3 = num;
|
|
}
|
|
let obj = { marginTop: tmp3, height: null, width: null };
|
|
obj[1] = 0;
|
|
let num2;
|
|
if (horizontal) {
|
|
num2 = 0;
|
|
}
|
|
obj = { style: obj, ref: closure_16 };
|
|
obj[2] = num2;
|
|
return num2(horizontal(renderItem[19]).CompatView, obj);
|
|
}, items6);
|
|
items7 = [, ];
|
|
items7[0] = horizontal;
|
|
items7[1] = result1;
|
|
tmp44 = c13;
|
|
tmp20Result5 = tmp20(() => {
|
|
let tmp = null;
|
|
if (result1) {
|
|
const obj = { horizontal: null, scrollAnchorRef: null };
|
|
const _Boolean = Boolean;
|
|
obj[0] = Boolean(horizontal);
|
|
obj[1] = closure_21;
|
|
tmp = num2(horizontal(renderItem[20]).ScrollAnchor, obj);
|
|
}
|
|
return tmp;
|
|
}, items7);
|
|
obj = { value: tmp20Result, children: null };
|
|
tmp45 = jsxs;
|
|
num3 = 1;
|
|
obj1 = {
|
|
style: items8,
|
|
ref: tmp9,
|
|
collapsable: false,
|
|
onLayout(nativeEvent) {
|
|
const current = ref2.current;
|
|
let num;
|
|
if (current != null) {
|
|
num = current.width;
|
|
}
|
|
if (num == null) {
|
|
num = 0;
|
|
}
|
|
let result = horizontal(renderItem[12]).areDimensionsNotEqual(nativeEvent.nativeEvent.layout.width, num);
|
|
if (!result) {
|
|
const current2 = ref2.current;
|
|
let num2;
|
|
if (current2 != null) {
|
|
num2 = current2.height;
|
|
}
|
|
if (num2 == null) {
|
|
num2 = 0;
|
|
}
|
|
result = horizontal(renderItem[12]).areDimensionsNotEqual(nativeEvent.nativeEvent.layout.height, num2);
|
|
const tmpResult = horizontal(renderItem[12]);
|
|
}
|
|
if (result) {
|
|
tmp20Result.layout();
|
|
}
|
|
},
|
|
children: null
|
|
};
|
|
items8 = [, , ];
|
|
items8[0] = { flex: num3, overflow: "hidden" };
|
|
items8[1] = style;
|
|
items8[2] = invertedTransformStyle;
|
|
obj2 = {};
|
|
merged = Object.assign(tmp);
|
|
obj2.horizontal = horizontal;
|
|
obj2.ref = tmp8;
|
|
obj2.onScroll = tmp20Result2;
|
|
obj2.maintainVisibleContentPosition = tmp20Result3;
|
|
obj2.removeClippedSubviews = false;
|
|
obj2.refreshControl = refreshControl;
|
|
merged1 = Object.assign(overrideProps);
|
|
items9 = [, , , , , , ];
|
|
items9[0] = tmp20Result5;
|
|
tmp48 = tmp26;
|
|
if (tmp26) {
|
|
tmp48 = tmp20Result4;
|
|
}
|
|
items9[1] = tmp48;
|
|
items9[2] = renderHeader;
|
|
tmp49 = !tmp26;
|
|
if (!tmp26) {
|
|
tmp49 = tmp20Result4;
|
|
}
|
|
items9[3] = tmp49;
|
|
obj3 = { viewHolderCollectionRef: tmp24, data, horizontal, renderStack: null, getLayout: null, getAdjustmentMargin: null, refHolder: null, onSizeChanged: null, renderItem: null, extraData: null, onCommitLayoutEffect: null, onCommitEffect: null, CellRendererComponent: null, ItemSeparatorComponent: null, isInLastRow: null, getChildContainerLayout: null, currentStickyIndex: null, hideStickyHeaderRelatedCell: null, inverted: null };
|
|
obj3[3] = recyclerViewManager.getRenderStack();
|
|
obj3[4] = function getLayout(arg0) {
|
|
return recyclerViewManager.getLayout(arg0);
|
|
};
|
|
obj3[5] = function getAdjustmentMargin() {
|
|
if (closure_42) {
|
|
if (recyclerViewManager.hasLayout()) {
|
|
const size = obj.getWindowSize();
|
|
const size2 = obj.getChildContainerDimensions();
|
|
const _Math = Math;
|
|
return Math.max(0, (horizontal ? size.width : size.height) - (horizontal ? size2.width : size2.height) - obj.firstItemOffset);
|
|
}
|
|
}
|
|
return 0;
|
|
};
|
|
obj3[6] = tmp21;
|
|
obj3[7] = tmp32;
|
|
obj3[8] = renderItem;
|
|
obj3[9] = extraData;
|
|
obj3[10] = function onCommitLayoutEffect(arg0) {
|
|
callback4();
|
|
if (recyclerViewContext != null) {
|
|
const result = recyclerViewContext.unmarkChildLayoutAsPending(closure_38);
|
|
}
|
|
if (callback != null) {
|
|
callback();
|
|
}
|
|
};
|
|
obj3[11] = function onCommitEffect() {
|
|
first.markRenderComplete();
|
|
const result = recyclerViewManager.updateAverageRenderTime(first.getAverageRenderTime());
|
|
callback4();
|
|
checkBounds();
|
|
const itemViewability = recyclerViewManager.computeItemViewability();
|
|
recyclerViewManager.animationOptimizationsEnabled = false;
|
|
};
|
|
obj3[12] = CellRendererComponent;
|
|
obj3[13] = ItemSeparatorComponent;
|
|
obj3[14] = function isInLastRow(arg0) {
|
|
return recyclerViewManager.isInLastRow(arg0);
|
|
};
|
|
obj3[15] = function getChildContainerLayout() {
|
|
let childContainerDimensions;
|
|
if (recyclerViewManager.hasLayout()) {
|
|
childContainerDimensions = recyclerViewManager.getChildContainerDimensions();
|
|
}
|
|
return childContainerDimensions;
|
|
};
|
|
obj3[16] = first1;
|
|
obj3[17] = flag2;
|
|
obj3[18] = inverted;
|
|
items9[4] = tmp44(require("ViewHolderCollection").ViewHolderCollection, obj3);
|
|
items9[5] = renderEmpty;
|
|
items9[6] = renderFooter;
|
|
obj2.children = items9;
|
|
items10 = [, , ];
|
|
items10[0] = tmp45(CompatScrollView, obj2);
|
|
tmp50 = null;
|
|
if (stickyHeaderIndices) {
|
|
tmp50 = null;
|
|
if (stickyHeaderIndices.length > 0) {
|
|
tmp50 = renderStickyHeaderBackdrop;
|
|
}
|
|
}
|
|
items10[1] = tmp50;
|
|
items10[2] = tmp20Result1;
|
|
obj1[4] = items10;
|
|
obj[1] = tmp45(require("CompatView").CompatView, obj1);
|
|
return tmp44(require("context").RecyclerViewContextProvider, obj);
|
|
}
|
|
}
|
|
RecyclerViewComponent.displayName = "FlashList";
|
|
|
|
export const RecyclerView = require("CompatView").memo(forwardRef(RecyclerViewComponent));
|