SheWhoReignsSupreme/decord
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1
decord/source/305__isNativeReflectConstruct.js

1769 lines
70 KiB
JavaScript
Raw Normal View History

chore: update source for alpha 340.0
2026-07-20 16:05:17 +00:00
// Module ID: 305
// Function ID: 4607
// Name: _isNativeReflectConstruct
// Dependencies: []
// Module 305 (_isNativeReflectConstruct)
let Platform;
let StyleSheet;
function _isNativeReflectConstruct() {
let closure_0 = !valueOf.call(Reflect.construct(Boolean, [], () => {
}));
function _isNativeReflectConstruct() {
return closure_0;
}
const result = _isNativeReflectConstruct();
}
function getScrollingThreshold(arg0, arg1) {
return arg0 * arg1 / 2;
}
chore: update source for alpha 340.1
2026-07-21 06:55:02 +00:00
let closure_4 = ["<string:2426404864>"];
chore: update source for alpha 340.0
2026-07-20 16:05:17 +00:00
let closure_5 = importDefault(dependencyMap[0]);
let closure_6 = importDefault(dependencyMap[1]);
let closure_7 = importDefault(dependencyMap[2]);
let closure_8 = importDefault(dependencyMap[3]);
let closure_9 = importDefault(dependencyMap[4]);
let closure_10 = importDefault(dependencyMap[5]);
let closure_11 = importDefault(dependencyMap[6]);
let closure_12 = importDefault(dependencyMap[7]);
let closure_13 = importAll(dependencyMap[8]);
({ cloneElement: closure_14, isValidElement: closure_15 } = arg1(dependencyMap[8]));
const tmp3 = arg1(dependencyMap[9]);
({ I18nManager: closure_16, Platform, RefreshControl: closure_17, ScrollView: closure_18, StyleSheet } = tmp3);
({ View: closure_20, findNodeHandle: closure_21 } = tmp3);
const tmp2 = arg1(dependencyMap[8]);
({ jsx: closure_22, jsxs: closure_23 } = arg1(dependencyMap[10]));
let closure_24 = false;
let closure_25 = "";
const tmp5 = (arg0) => {
class VirtualizedList {
constructor(arg0) {
self = this;
tmp = closure_8(this, VirtualizedList);
items = [];
items[0] = arg0;
obj = closure_11(VirtualizedList);
tmp2 = closure_10;
if (closure_27()) {
tmp4 = globalThis;
_Reflect = Reflect;
tmp5 = closure_11;
constructResult = Reflect.construct(obj, items, closure_11(self).constructor);
} else {
constructResult = obj.apply(self, items);
}
tmp2Result = tmp2(self, constructResult);
VirtualizedList = tmp2Result;
tmp2Result._getScrollMetrics = () => tmp2Result._scrollMetrics;
tmp2Result._getOutermostParentListRef = () => {
if (tmp2Result._isNestedWithSameOrientation()) {
const context = tmp.context;
let outermostParentListRef = context.getOutermostParentListRef();
} else {
outermostParentListRef = tmp;
}
return outermostParentListRef;
};
tmp2Result._registerAsNestedChild = (ref) => {
const _nestedChildLists = tmp2Result._nestedChildLists;
_nestedChildLists.add(ref.ref, ref.cellKey);
if (tmp2Result._hasInteracted) {
ref.ref.recordInteraction();
ref = ref.ref;
}
};
tmp2Result._unregisterAsNestedChild = (ref) => {
const _nestedChildLists = tmp2Result._nestedChildLists;
_nestedChildLists.remove(ref.ref);
};
tmp2Result._onUpdateSeparators = (arr) => {
const item = arr.forEach((arg0) => {
let obj = null != arg0;
if (obj) {
obj = arg1._cellRefs[arg0];
}
if (obj) {
obj.updateSeparatorProps(arg1);
}
});
};
tmp2Result._getSpacerKey = (arg0) => {
let str = "width";
if (arg0) {
str = "height";
}
return str;
};
tmp2Result._cellRefs = {};
tmp6 = closure_1(closure_3[11]);
tmp6 = new tmp6();
tmp2Result._listMetrics = tmp6;
tmp2Result._footerLength = 0;
tmp2Result._hasTriggeredInitialScrollToIndex = false;
tmp2Result._hasInteracted = false;
tmp2Result._hasMore = false;
tmp2Result._hasWarned = {};
tmp2Result._headerLength = 0;
tmp2Result._hiPriInProgress = false;
map = new Map();
tmp2Result._indicesToKeys = map;
tmp2Result._lastFocusedCellKey = null;
tmp9 = closure_1(closure_3[12]);
tmp9 = new tmp9();
tmp2Result._nestedChildLists = tmp9;
tmp2Result._offsetFromParentVirtualizedList = 0;
tmp2Result._pendingViewabilityUpdate = false;
tmp2Result._prevParentOffset = 0;
tmp2Result._scrollMetrics = {};
tmp2Result._scrollRef = null;
tmp2Result._sentStartForContentLength = 0;
tmp2Result._sentEndForContentLength = 0;
tmp2Result._updateCellsToRenderTimeoutID = null;
tmp2Result._viewabilityTuples = [];
tmp2Result._captureScrollRef = (_scrollRef) => {
tmp2Result._scrollRef = _scrollRef;
};
tmp2Result._defaultRenderScrollComponent = (onRefresh) => {
let progressViewOffset = onRefresh.onRefresh;
if (tmp2Result._isNestedWithSameOrientation()) {
const onContentSizeChange = onRefresh.onContentSizeChange;
const _Object2 = Object;
return callback4(closure_20, Object.assign({}, callback3(onRefresh, closure_4)));
} else if (progressViewOffset) {
const refreshing = onRefresh.refreshing;
let str = "undefined";
if (null != refreshing) {
str = refreshing;
}
callback(closure_3[13])("boolean" === typeof onRefresh.refreshing, ``refreshing` prop must be set as a boolean in order to use `onRefresh`, but got `${tmp9(str)}``);
let obj = {};
if (null == onRefresh.refreshControl) {
obj = { refreshing: onRefresh.refreshing, onRefresh: progressViewOffset };
progressViewOffset = onRefresh.progressViewOffset;
obj.progressViewOffset = progressViewOffset;
let refreshControl = callback4(closure_17, obj);
} else {
refreshControl = onRefresh.refreshControl;
}
obj.refreshControl = refreshControl;
callback4(closure_18, Object.assign({}, onRefresh, obj));
const tmp12 = callback4;
const tmp13 = closure_18;
const tmp6 = callback(closure_3[13]);
} else {
const _Object = Object;
return callback4(closure_18, Object.assign({}, onRefresh));
}
};
tmp2Result._onCellLayout = (layout, cellKey, cellIndex) => {
const _listMetrics = tmp2Result._listMetrics;
if (_listMetrics.notifyCellLayout(obj)) {
const result = tmp2Result._scheduleCellsToRenderUpdate();
}
const result1 = tmp2Result._triggerRemeasureForChildListsInCell(cellKey);
tmp2Result._computeBlankness();
tmp2Result._updateViewableItems(tmp2Result.props, tmp2Result.state.cellsAroundViewport);
};
tmp2Result._onCellFocusCapture = (_lastFocusedCellKey) => {
tmp2Result._lastFocusedCellKey = _lastFocusedCellKey;
if (obj.deferFlatListFocusChangeRenderUpdate()) {
const result = obj2._scheduleCellsToRenderUpdate();
} else {
obj2._updateCellsToRender();
}
};
tmp2Result._onCellUnmount = (arg0) => {
delete r1[r2];
const _listMetrics = tmp2Result._listMetrics;
_listMetrics.notifyCellUnmounted(arg0);
};
tmp2Result._onLayout = (nativeEvent) => {
if (tmp2Result._isNestedWithSameOrientation()) {
const result = obj.measureLayoutRelativeToContainingList();
} else {
obj._scrollMetrics.visibleLength = obj._selectLength(nativeEvent.nativeEvent.layout);
}
if (tmp2Result.props.onLayout) {
const props = tmp2Result.props;
props.onLayout(nativeEvent);
}
const result1 = tmp2Result._scheduleCellsToRenderUpdate();
const result2 = tmp2Result._maybeCallOnEdgeReached();
};
tmp2Result._onLayoutEmpty = (arg0) => {
if (tmp2Result.props.onLayout) {
const props = tmp2Result.props;
props.onLayout(arg0);
}
};
tmp2Result._onLayoutFooter = (nativeEvent) => {
const result = tmp2Result._triggerRemeasureForChildListsInCell(tmp2Result._getFooterCellKey());
tmp2Result._footerLength = tmp2Result._selectLength(nativeEvent.nativeEvent.layout);
};
tmp2Result._onLayoutHeader = (nativeEvent) => {
tmp2Result._headerLength = tmp2Result._selectLength(nativeEvent.nativeEvent.layout);
};
tmp2Result._onContentSizeChange = (width, height) => {
const _listMetrics = tmp2Result._listMetrics;
let obj = { layout: obj, orientation: tmp2Result._orientation() };
obj = { width, height };
const result = _listMetrics.notifyListContentLayout(obj);
const result1 = tmp2Result._maybeScrollToInitialScrollIndex(width, height);
if (tmp2Result.props.onContentSizeChange) {
const props = tmp2Result.props;
props.onContentSizeChange(width, height);
}
const result2 = tmp2Result._scheduleCellsToRenderUpdate();
const result3 = tmp2Result._maybeCallOnEdgeReached();
};
tmp2Result._convertParentScrollMetrics = (offset) => {
const diff = offset.offset - tmp2Result._offsetFromParentVirtualizedList;
const _listMetrics = tmp2Result._listMetrics;
const diff1 = diff - tmp2Result._scrollMetrics.offset;
return { visibleLength: offset.visibleLength, contentLength: _listMetrics.getContentLength(), offset: diff, dOffset: diff1 };
};
tmp2Result._onScroll = (timeStamp) => {
let contentLength;
let dOffset;
let offset;
let visibleLength;
const tmp2Result = timeStamp;
const _nestedChildLists = tmp2Result._nestedChildLists;
const item = _nestedChildLists.forEach((_onScroll) => {
_onScroll._onScroll(_onScroll);
});
if (tmp2Result.props.onScroll) {
const props = tmp2Result.props;
props.onScroll(timeStamp);
}
timeStamp = timeStamp.timeStamp;
const _selectLengthResult = tmp2Result._selectLength(timeStamp.nativeEvent.layoutMeasurement);
const result = tmp2Result._offsetFromScrollEvent(timeStamp);
dOffset = result - tmp2Result._scrollMetrics.offset;
visibleLength = _selectLengthResult;
contentLength = tmp2Result._selectLength(timeStamp.nativeEvent.contentSize);
offset = result;
if (tmp2Result._isNestedWithSameOrientation()) {
const _listMetrics = tmp2Result._listMetrics;
if (0 !== _listMetrics.getContentLength()) {
let obj = { visibleLength: _selectLengthResult, offset: result };
const result1 = tmp2Result._convertParentScrollMetrics(obj);
({ visibleLength, contentLength, offset, dOffset } = result1);
}
}
let num2 = 1;
let num3 = 1;
if (tmp2Result._scrollMetrics.timestamp) {
const _Math = Math;
num3 = Math.max(num2, timeStamp - tmp2Result._scrollMetrics.timestamp);
}
const result2 = dOffset / num3;
let tmp11 = num3 > 500;
if (tmp11) {
tmp11 = tmp2Result._scrollMetrics.dt > 500;
}
if (tmp11) {
tmp11 = contentLength > 5 * visibleLength;
}
if (tmp11) {
tmp11 = !tmp2Result._hasWarned.perf;
}
if (tmp11) {
obj = { dt: num3, prevDt: tmp2Result._scrollMetrics.dt, contentLength };
callback(closure_3[15])("VirtualizedList: You have a large list that is slow to update - make sure your renderItem function renders components that follow React performance best practices like PureComponent, shouldComponentUpdate, etc.", obj);
tmp2Result._hasWarned.perf = true;
}
if (timeStamp.nativeEvent.zoomScale >= 0) {
num2 = timeStamp.nativeEvent.zoomScale;
}
obj = { dt: num3, dOffset, offset, timestamp: timeStamp, velocity: result2, visibleLength, zoomScale: num2 };
tmp2Result._scrollMetrics = obj;
if (tmp2Result.state.pendingScrollUpdateCount > 0) {
tmp2Result.setState((pendingScrollUpdateCount) => ({ pendingScrollUpdateCount: pendingScrollUpdateCount.pendingScrollUpdateCount - 1 }));
}
tmp2Result._updateViewableItems(tmp2Result.props, tmp2Result.state.cellsAroundViewport);
if (tmp2Result.props) {
const result3 = tmp2Result._maybeCallOnEdgeReached();
if (0 !== result2) {
const _fillRateHelper = tmp2Result._fillRateHelper;
_fillRateHelper.activate();
}
tmp2Result._computeBlankness();
const result4 = tmp2Result._scheduleCellsToRenderUpdate();
}
};
tmp2Result._onScrollBeginDrag = (arg0) => {
const _nestedChildLists = tmp2Result._nestedChildLists;
const item = _nestedChildLists.forEach((_onScrollBeginDrag) => {
_onScrollBeginDrag._onScrollBeginDrag(_onScrollBeginDrag);
});
const _viewabilityTuples = tmp2Result._viewabilityTuples;
const item1 = _viewabilityTuples.forEach((viewabilityHelper) => {
viewabilityHelper = viewabilityHelper.viewabilityHelper;
viewabilityHelper.recordInteraction();
});
arg0._hasInteracted = true;
if (arg0.props.onScrollBeginDrag) {
const props = tmp2Result.props;
props.onScrollBeginDrag(arg0);
}
};
tmp2Result._onScrollEndDrag = (nativeEvent) => {
const _nestedChildLists = tmp2Result._nestedChildLists;
const item = _nestedChildLists.forEach((_onScrollEndDrag) => {
_onScrollEndDrag._onScrollEndDrag(_onScrollEndDrag);
});
const velocity = nativeEvent.nativeEvent.velocity;
if (velocity) {
tmp2Result._scrollMetrics.velocity = tmp2Result._selectOffset(velocity);
}
nativeEvent._computeBlankness();
if (nativeEvent.props.onScrollEndDrag) {
const props = tmp2Result.props;
props.onScrollEndDrag(nativeEvent);
}
};
tmp2Result._onMomentumScrollBegin = (arg0) => {
const _nestedChildLists = tmp2Result._nestedChildLists;
const item = _nestedChildLists.forEach((_onMomentumScrollBegin) => {
const result = _onMomentumScrollBegin._onMomentumScrollBegin(_onMomentumScrollBegin);
});
if (arg0.props.onMomentumScrollBegin) {
const props = tmp2Result.props;
const result = props.onMomentumScrollBegin(arg0);
}
};
tmp2Result._onMomentumScrollEnd = (nativeEvent) => {
const _nestedChildLists = tmp2Result._nestedChildLists;
const item = _nestedChildLists.forEach((_onMomentumScrollEnd) => {
_onMomentumScrollEnd._onMomentumScrollEnd(_onMomentumScrollEnd);
});
nativeEvent._scrollMetrics.velocity = 0;
nativeEvent._computeBlankness();
if (nativeEvent.props.onMomentumScrollEnd) {
const props = tmp2Result.props;
props.onMomentumScrollEnd(nativeEvent);
}
};
tmp2Result._updateCellsToRender = () => {
tmp2Result._updateViewableItems(tmp2Result.props, tmp2Result.state.cellsAroundViewport);
tmp2Result.setState((cellsAroundViewport, getItemCount) => {
cellsAroundViewport = closure_0._adjustCellsAroundViewport(getItemCount, cellsAroundViewport.cellsAroundViewport, cellsAroundViewport.pendingScrollUpdateCount);
const renderMask = closure_0._createRenderMask(getItemCount, cellsAroundViewport, closure_0._getNonViewportRenderRegions(getItemCount));
if (cellsAroundViewport.first === cellsAroundViewport.cellsAroundViewport.first) {
return { cellsAroundViewport, renderMask };
}
});
};
tmp2Result._createViewToken = (index, isViewable, getItem) => {
const value = getItem.getItem(getItem.data, index);
return { index, item: value, key: tmp2Result._keyExtractor(value, index, getItem), isViewable };
};
tmp2Result._getNonViewportRenderRegions = (getItemCount) => {
if (tmp2Result._lastFocusedCellKey) {
if (tmp2Result._cellRefs[closure_0._lastFocusedCellKey]) {
const index = tmp2Result._cellRefs[closure_0._lastFocusedCellKey].props.index;
const itemCount = getItemCount.getItemCount(getItemCount.data);
if (index < itemCount) {
if (tmp2Result._getItemKey(getItemCount, index) === tmp2Result._lastFocusedCellKey) {
let diff = index - 1;
let tmp6 = index;
if (diff >= 0) {
let tmp5 = index;
let num = 0;
tmp6 = index;
if (0 < tmp2Result._scrollMetrics.visibleLength) {
const diff1 = tmp5 - 1;
const _listMetrics = tmp2Result._listMetrics;
num = num + _listMetrics.getCellMetricsApprox(diff, getItemCount).length;
diff = diff - 1;
tmp6 = diff1;
while (diff >= 0) {
let tmp10 = tmp2Result;
tmp5 = diff1;
tmp6 = diff1;
if (num >= tmp2Result._scrollMetrics.visibleLength) {
break;
}
}
}
}
let sum = index + 1;
let tmp12 = index;
if (sum < itemCount) {
let tmp14 = index;
let num2 = 0;
tmp12 = index;
if (0 < tmp2Result._scrollMetrics.visibleLength) {
const sum1 = tmp14 + 1;
const _listMetrics2 = tmp2Result._listMetrics;
num2 = num2 + _listMetrics2.getCellMetricsApprox(sum, getItemCount).length;
sum = sum + 1;
tmp12 = sum1;
while (sum < itemCount) {
let tmp17 = tmp2Result;
tmp14 = sum1;
tmp12 = sum1;
if (num2 >= tmp2Result._scrollMetrics.visibleLength) {
break;
}
}
}
}
const obj = { first: tmp6, last: tmp12 };
const items = [obj];
return items;
}
}
return [];
}
}
return [];
};
_checkPropsResult = tmp2Result._checkProps(arg0);
tmp12 = closure_1(closure_3[16]);
tmp12 = new tmp12(tmp2Result._listMetrics);
tmp2Result._fillRateHelper = tmp12;
props = tmp2Result.props;
if (tmp2Result.props.viewabilityConfigCallbackPairs) {
prop = props.viewabilityConfigCallbackPairs;
tmp2Result._viewabilityTuples = prop.map((viewabilityConfig) => {
const obj = {};
let tmp = callback(closure_3[17]);
tmp = new tmp(viewabilityConfig.viewabilityConfig);
obj.viewabilityHelper = tmp;
obj.onViewableItemsChanged = viewabilityConfig.onViewableItemsChanged;
return obj;
});
} else {
({ onViewableItemsChanged, viewabilityConfig } = props);
if (onViewableItemsChanged) {
_viewabilityTuples = tmp2Result._viewabilityTuples;
obj = {};
tmp14 = closure_1;
tmp15 = closure_3;
num = 17;
tmp16 = closure_1(closure_3[17]);
prototype = tmp16.prototype;
tmp17 = new.target;
tmp18 = new.target;
tmp19 = viewabilityConfig;
tmp16 = new tmp16(viewabilityConfig);
tmp21 = tmp16;
obj.viewabilityHelper = tmp16;
obj.onViewableItemsChanged = onViewableItemsChanged;
arr = _viewabilityTuples.push(obj);
}
}
_initialRenderRegionResult = VirtualizedList._initialRenderRegion(arg0);
maintainVisibleContentPosition = tmp2Result.props.maintainVisibleContentPosition;
minIndexForVisible = undefined;
if (null != maintainVisibleContentPosition) {
minIndexForVisible = maintainVisibleContentPosition.minIndexForVisible;
}
num2 = 0;
if (null != minIndexForVisible) {
num2 = minIndexForVisible;
}
obj1 = { cellsAroundViewport: _initialRenderRegionResult, renderMask: VirtualizedList._createRenderMask(arg0, _initialRenderRegionResult) };
props2 = tmp2Result.props;
_getItemKeyResult = null;
if (props2.getItemCount(tmp2Result.props.data) > num2) {
tmp26 = VirtualizedList;
_getItemKeyResult = VirtualizedList._getItemKey(tmp2Result.props, num2);
}
obj1.firstVisibleItemKey = _getItemKeyResult;
num3 = 0;
if (null != tmp2Result.props.initialScrollIndex) {
num3 = 0;
if (tmp2Result.props.initialScrollIndex > 0) {
num3 = 1;
}
}
obj1.pendingScrollUpdateCount = num3;
tmp2Result.state = obj1;
return tmp2Result;
}
}
const arg1 = VirtualizedList;
callback2(VirtualizedList, arg0);
let obj = {
key: "scrollToEnd",
value: function scrollToEnd(animated) {
const self = this;
const props = self.props;
const diff = props.getItemCount(self.props.data) - 1;
if (diff >= 0) {
const _listMetrics = self._listMetrics;
const cellMetricsApprox = _listMetrics.getCellMetricsApprox(diff, self.props);
const _Math = Math;
const obj = { animated: tmp, offset: Math.max(0, cellMetricsApprox.offset + cellMetricsApprox.length + self._footerLength - self._scrollMetrics.visibleLength) };
self.scrollToOffset(obj);
}
}
};
const items = [obj, , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ];
obj = {
key: "scrollToIndex",
value: function scrollToIndex(animated) {
let data;
let getItemCount;
let index;
let onScrollToIndexFailed;
let viewOffset;
let viewPosition;
const self = this;
const props = this.props;
({ data, getItemCount, onScrollToIndexFailed } = props);
({ index, viewOffset, viewPosition } = animated);
callback(closure_3[13])(index >= 0, "scrollToIndex out of range: requested index " + index + " but minimum is 0");
const tmp = callback(closure_3[13]);
const tmp2 = index >= 0;
const tmp4 = callback(closure_3[13]);
tmp4(getItemCount(data) >= 1, "scrollToIndex out of range: item length " + getItemCount(data) + " but minimum is 1");
const tmp5 = getItemCount(data) >= 1;
const tmp7 = callback(closure_3[13]);
tmp7(index < getItemCount(data), "scrollToIndex out of range: requested index " + index + " is out of 0 to " + getItemCount(data) - 1);
if (!props.getItemLayout) {
const _listMetrics = self._listMetrics;
if (index > _listMetrics.getHighestMeasuredCellIndex()) {
callback(closure_3[13])(onScrollToIndexFailed, "scrollToIndex should be used in conjunction with getItemLayout or onScrollToIndexFailed, otherwise there is no way to know the location of offscreen indices or handle failures.");
let obj = {};
const _listMetrics2 = self._listMetrics;
obj.averageItemLength = _listMetrics2.getAverageCellLength();
const _listMetrics3 = self._listMetrics;
obj.highestMeasuredFrameIndex = _listMetrics3.getHighestMeasuredCellIndex();
obj.index = index;
const result = onScrollToIndexFailed(obj);
}
}
const _listMetrics4 = self._listMetrics;
const _listMetrics5 = self._listMetrics;
const cellMetricsApprox = _listMetrics4.getCellMetricsApprox(Math.floor(index), self.props);
const cellOffsetApprox = _listMetrics5.getCellOffsetApprox(index, self.props);
if (!viewPosition) {
viewPosition = 0;
}
const bound = Math.max(0, cellOffsetApprox - viewPosition * (self._scrollMetrics.visibleLength - cellMetricsApprox.length));
if (!viewOffset) {
viewOffset = 0;
}
obj = { offset: bound - viewOffset, animated: animated.animated };
self.scrollToOffset(obj);
}
};
items[1] = obj;
obj = {
key: "scrollToItem",
value: function scrollToItem(arg0) {
const self = this;
const props = this.props;
const data = props.data;
const itemCount = props.getItemCount(data);
let num = 0;
if (0 < itemCount) {
while (tmp2(data, num) !== tmp) {
num = num + 1;
}
const _Object = Object;
const obj = { index: num };
self.scrollToIndex(Object.assign({}, arg0, obj));
}
}
};
items[2] = obj;
items[3] = {
key: "scrollToOffset",
value: function scrollToOffset(arg0) {
const self = this;
const _scrollRef = this._scrollRef;
if (null != _scrollRef) {
if (null != _scrollRef.scrollTo) {
const _orientationResult = self._orientation();
if (_orientationResult.horizontal) {
if (_orientationResult.rtl) {
const _listMetrics = self._listMetrics;
if (!_listMetrics.hasContentLength()) {
const _console2 = console;
console.warn("scrollToOffset may not be called in RTL before content is laid out");
}
}
}
const _Object = Object;
const obj = { animated: tmp };
_scrollRef.scrollTo(Object.assign(obj, self._scrollToParamsFromOffset(tmp2)));
} else {
const _console = console;
console.warn("No scrollTo method provided. This may be because you have two nested VirtualizedLists with the same orientation, or because you are using a custom component that does not implement scrollTo.");
}
}
}
};
items[4] = {
key: "_scrollToParamsFromOffset",
value: function _scrollToParamsFromOffset(arg0) {
const self = this;
const _orientationResult = this._orientation();
const horizontal = _orientationResult.horizontal;
if (horizontal) {
if (_orientationResult.rtl) {
const _listMetrics = self._listMetrics;
const cartesianOffsetResult = _listMetrics.cartesianOffset(arg0 + self._scrollMetrics.visibleLength);
let obj = {};
if (horizontal) {
obj.x = cartesianOffsetResult;
let tmp4 = obj;
} else {
obj.y = cartesianOffsetResult;
tmp4 = obj;
}
return tmp4;
}
}
obj = {};
if (horizontal) {
obj.x = arg0;
let tmp2 = obj;
} else {
obj.y = arg0;
tmp2 = obj;
}
return tmp2;
}
};
items[5] = {
key: "recordInteraction",
value: function recordInteraction() {
const _nestedChildLists = this._nestedChildLists;
const item = _nestedChildLists.forEach((recordInteraction) => {
recordInteraction.recordInteraction();
});
const _viewabilityTuples = this._viewabilityTuples;
const item1 = _viewabilityTuples.forEach((viewabilityHelper) => {
viewabilityHelper = viewabilityHelper.viewabilityHelper;
viewabilityHelper.recordInteraction();
});
this._updateViewableItems(this.props, this.state.cellsAroundViewport);
}
};
items[6] = {
key: "flashScrollIndicators",
value: function flashScrollIndicators() {
if (null != this._scrollRef) {
const _scrollRef = this._scrollRef;
const result = _scrollRef.flashScrollIndicators();
}
}
};
items[7] = {
key: "getScrollResponder",
value: function getScrollResponder() {
const self = this;
if (this._scrollRef) {
if (self._scrollRef.getScrollResponder) {
const _scrollRef = self._scrollRef;
return _scrollRef.getScrollResponder();
}
}
}
};
items[8] = {
key: "getScrollableNode",
value: function getScrollableNode() {
const self = this;
if (this._scrollRef) {
if (self._scrollRef.getScrollableNode) {
const _scrollRef = self._scrollRef;
let scrollableNode = _scrollRef.getScrollableNode();
}
return scrollableNode;
}
scrollableNode = callback7(self._scrollRef);
}
};
items[9] = {
key: "getScrollRef",
value: function getScrollRef() {
const self = this;
if (this._scrollRef) {
if (self._scrollRef.getScrollRef) {
const _scrollRef2 = self._scrollRef;
let _scrollRef = _scrollRef2.getScrollRef();
}
return _scrollRef;
}
_scrollRef = self._scrollRef;
}
};
items[10] = {
key: "setNativeProps",
value: function setNativeProps(arg0) {
if (this._scrollRef) {
const _scrollRef = this._scrollRef;
_scrollRef.setNativeProps(arg0);
}
}
};
items[11] = {
key: "_getCellKey",
value: function _getCellKey() {
const context = this.context;
let str;
if (null != context) {
str = context.cellKey;
}
if (!str) {
str = "rootList";
}
return str;
}
};
items[12] = {
key: "hasMore",
value: function hasMore() {
return this._hasMore;
}
};
items[13] = {
key: "_checkProps",
value: function _checkProps(arg0) {
let data;
let getItemCount;
let initialScrollIndex;
let onScroll;
let windowSize;
const self = this;
({ onScroll, getItemCount, initialScrollIndex } = arg0);
({ windowSize, data } = arg0);
let tmp2 = !onScroll;
if (!tmp2) {
tmp2 = !onScroll.__isNative;
}
callback(closure_3[13])(tmp2, "Components based on VirtualizedList must be wrapped with Animated.createAnimatedComponent to support native onScroll events with useNativeDriver");
const tmp = callback(closure_3[13]);
const tmp4 = callback(closure_3[13]);
tmp4(VirtualizedList(closure_3[18]).windowSizeOrDefault(windowSize) > 0, "VirtualizedList: The windowSize prop must be present and set to a value greater than 0.");
callback(closure_3[13])(getItemCount, "VirtualizedList: The \"getItemCount\" prop must be provided");
const itemCount = getItemCount(data);
let initialScrollIndex2 = null == initialScrollIndex || self._hasTriggeredInitialScrollToIndex;
if (!initialScrollIndex2) {
let tmp8 = initialScrollIndex < 0;
if (!tmp8) {
tmp8 = itemCount > 0 && initialScrollIndex >= itemCount;
const tmp9 = itemCount > 0 && initialScrollIndex >= itemCount;
}
initialScrollIndex2 = !tmp8;
}
if (!initialScrollIndex2) {
initialScrollIndex2 = self._hasWarned.initialScrollIndex;
}
if (!initialScrollIndex2) {
const _console = console;
const _HermesInternal = HermesInternal;
console.warn("initialScrollIndex \"" + initialScrollIndex + "\" is not valid (list has " + itemCount + " items)");
self._hasWarned.initialScrollIndex = true;
}
}
};
items[14] = {
key: "_adjustCellsAroundViewport",
value: function _adjustCellsAroundViewport(onEndReachedThreshold, cellsAroundViewport, pendingScrollUpdateCount) {
let data;
let getItemCount;
const self = this;
({ data, getItemCount } = onEndReachedThreshold);
let obj = VirtualizedList(closure_3[18]);
const visibleLength = this._scrollMetrics.visibleLength;
const _listMetrics = this._listMetrics;
const result = obj.onEndReachedThresholdOrDefault(onEndReachedThreshold.onEndReachedThreshold);
const contentLength = _listMetrics.getContentLength();
if (visibleLength > 0) {
if (contentLength > 0) {
if (onEndReachedThreshold.disableVirtualization) {
let num = 0;
if (tmp3 < result * visibleLength) {
num = VirtualizedList(closure_3[18]).maxToRenderPerBatchOrDefault(onEndReachedThreshold.maxToRenderPerBatch);
const obj2 = VirtualizedList(closure_3[18]);
}
obj = { first: 0 };
const _Math = Math;
const sum = cellsAroundViewport.last + num;
obj.last = Math.min(sum, getItemCount(data) - 1);
let windowedRenderLimits = obj;
} else if (pendingScrollUpdateCount > 0) {
let result1 = cellsAroundViewport;
if (cellsAroundViewport.last >= getItemCount(data)) {
result1 = VirtualizedList._constrainToItemCount(cellsAroundViewport, onEndReachedThreshold);
}
return result1;
} else {
const obj4 = VirtualizedList(closure_3[19]);
const result2 = VirtualizedList(closure_3[18]).maxToRenderPerBatchOrDefault(onEndReachedThreshold.maxToRenderPerBatch);
const obj5 = VirtualizedList(closure_3[18]);
windowedRenderLimits = obj4.computeWindowedRenderLimits(onEndReachedThreshold, result2, VirtualizedList(closure_3[18]).windowSizeOrDefault(onEndReachedThreshold.windowSize), cellsAroundViewport, self._listMetrics, self._scrollMetrics);
const obj6 = VirtualizedList(closure_3[18]);
callback(closure_3[13])(windowedRenderLimits.last < getItemCount(data), "computeWindowedRenderLimits() should return range in-bounds");
const tmp22 = callback(closure_3[13]);
}
const _nestedChildLists = self._nestedChildLists;
if (_nestedChildLists.size() > 0) {
let last = self._findFirstChildWithMore(windowedRenderLimits.first, windowedRenderLimits.last);
if (null == last) {
last = windowedRenderLimits.last;
}
windowedRenderLimits.last = last;
}
return windowedRenderLimits;
}
}
let result3 = cellsAroundViewport;
if (cellsAroundViewport.last >= getItemCount(data)) {
result3 = VirtualizedList._constrainToItemCount(cellsAroundViewport, onEndReachedThreshold);
}
return result3;
}
};
items[15] = {
key: "_findFirstChildWithMore",
value: function _findFirstChildWithMore(first, last) {
let sum = first;
const self = this;
if (first <= last) {
while (true) {
let _indicesToKeys = self._indicesToKeys;
let value = _indicesToKeys.get(sum);
let tmp3 = sum;
if (null != value) {
let _nestedChildLists = self._nestedChildLists;
if (_nestedChildLists.anyInCell(value, (hasMore) => hasMore.hasMore())) {
break;
}
}
sum = sum + 1;
}
return sum;
}
return null;
}
};
items[16] = {
key: "componentDidMount",
value: function componentDidMount() {
const self = this;
if (this._isNestedWithSameOrientation()) {
const context = self.context;
const obj = { ref: self, cellKey: self.context.cellKey };
const result = context.registerAsNestedChild(obj);
}
}
};
items[17] = {
key: "componentWillUnmount",
value: function componentWillUnmount() {
const self = this;
if (this._isNestedWithSameOrientation()) {
const context = self.context;
const obj = { ref: self };
const result = context.unregisterAsNestedChild(obj);
}
clearTimeout(self._updateCellsToRenderTimeoutID);
const _viewabilityTuples = self._viewabilityTuples;
const item = _viewabilityTuples.forEach((viewabilityHelper) => {
viewabilityHelper = viewabilityHelper.viewabilityHelper;
viewabilityHelper.dispose();
});
const _fillRateHelper = self._fillRateHelper;
_fillRateHelper.deactivateAndFlush();
}
};
items[18] = {
key: "_pushCells",
value: function _pushCells(items, items1, arg2, first, last, arg5) {
let data;
let sum = first;
const VirtualizedList = items;
const self = this;
const props = this.props;
({ CellRendererComponent: closure_6, ItemSeparatorComponent: closure_7, ListItemComponent: closure_8, data } = props);
({ debug: closure_10, getItem: closure_11, getItemLayout: closure_12, horizontal: closure_13, renderItem: closure_14 } = props);
let num = 0;
if (props.ListHeaderComponent) {
num = 1;
}
const diff = props.getItemCount(data) - 1;
const bound = Math.min(diff, last);
if (sum <= bound) {
do {
let tmp4 = function _loop(self) {
const tmp = callback(data, sum);
const _keyExtractorResult = self._keyExtractor(tmp, sum, self.props);
self = _keyExtractorResult;
const _indicesToKeys = self._indicesToKeys;
const result = _indicesToKeys.set(sum, _keyExtractorResult);
if (arg2.has(sum + num)) {
arg1.push(self.length);
}
let enabledResult = null == closure_12 || closure_10;
if (!enabledResult) {
const _fillRateHelper = self._fillRateHelper;
enabledResult = _fillRateHelper.enabled();
}
let obj = { CellRendererComponent: closure_6 };
let tmp12;
if (sum < diff) {
tmp12 = closure_7;
}
obj.ItemSeparatorComponent = tmp12;
obj.ListItemComponent = closure_8;
obj.cellKey = _keyExtractorResult;
obj.horizontal = closure_13;
obj.index = sum;
obj.inversionStyle = arg5;
obj.item = tmp;
obj.prevCellKey = _keyExtractorResult;
({ _onUpdateSeparators: obj.onUpdateSeparators, _onCellFocusCapture: obj.onCellFocusCapture, _onCellUnmount: obj.onUnmount } = self);
obj.ref = function ref(arg0) {
_cellRefs._cellRefs[_keyExtractorResult] = arg0;
};
obj.renderItem = closure_14;
if (enabledResult) {
obj = { onCellLayout: self._onCellLayout };
enabledResult = obj;
}
self.push(closure_22(arg1(arg5[20]), Object.assign(obj, enabledResult), _keyExtractorResult));
}();
sum = sum + 1;
closure_17 = sum;
} while (sum <= bound);
}
}
};
items[19] = {
key: "_isNestedWithSameOrientation",
value: function _isNestedWithSameOrientation() {
const context = this.context;
let tmp2 = !context;
if (!tmp2) {
tmp2 = !!context.horizontal !== VirtualizedList(closure_3[18]).horizontalOrDefault(tmp.props.horizontal);
const obj = VirtualizedList(closure_3[18]);
const tmp3 = !context.horizontal;
}
return !tmp2;
}
};
items[20] = {
key: "_renderEmptyComponent",
value: function _renderEmptyComponent(type, arg1) {
const VirtualizedList = type;
const self = this;
let tmp = type;
if (type.type !== React.Fragment) {
const obj = {
onLayout(arg0) {
self._onLayoutEmpty(arg0);
if (arg0.props.onLayout) {
const props = arg0.props;
props.onLayout(arg0);
}
},
style: closure_19.compose(arg1, type.props.style)
};
tmp = callback5(type, obj);
}
return tmp;
}
};
items[21] = {
key: "render",
value: function render() {
let ListEmptyComponent;
let ListFooterComponent;
let ListHeaderComponent;
const self = this;
this._checkProps(this.props);
({ ListEmptyComponent, ListFooterComponent, ListHeaderComponent } = this.props);
if (!this.props.inverted) {
const items = [];
const _Set = Set;
const set = new Set(self.props.stickyHeaderIndices);
let obj1 = set;
const items1 = [];
if (ListHeaderComponent) {
if (obj1.has(0)) {
items1.push(0);
}
let tmp17 = ListHeaderComponent;
if (!callback6(ListHeaderComponent)) {
tmp17 = callback8(ListHeaderComponent, {});
}
let obj = { cellKey: `${self._getCellKey()}-header` };
obj = { collapsable: false, onLayout: self._onLayoutHeader, style: closure_19.compose(tmp8, self.props.ListHeaderComponentStyle), children: tmp17 };
obj.children = callback8(closure_20, obj);
items.push(callback8(VirtualizedList(closure_3[21]).VirtualizedListCellContextProvider, obj, "$header"));
}
const props = self.props;
const itemCount = props.getItemCount(tmp2);
if (0 === itemCount) {
if (ListEmptyComponent) {
let tmp29 = ListEmptyComponent;
if (!callback6(ListEmptyComponent)) {
tmp29 = callback8(ListEmptyComponent, {});
}
obj1 = { cellKey: `${self._getCellKey()}-empty`, children: self._renderEmptyComponent(tmp29, tmp8) };
items.push(callback8(VirtualizedList(closure_3[21]).VirtualizedListCellContextProvider, obj1, "$empty"));
}
}
if (itemCount > 0) {
let closure_24 = false;
let closure_25 = "";
const _getSpacerKeyResult = self._getSpacerKey(!tmp3);
const renderMask = self.state.renderMask;
const enumerateRegionsResult = renderMask.enumerateRegions();
let tmp37 = null;
if (null != enumerateRegionsResult[enumerateRegionsResult.length - 1]) {
tmp37 = null;
if (tmp93.isSpacer) {
tmp37 = tmp93;
}
}
const iter = enumerateRegionsResult[Symbol.iterator]();
const nextResult = iter.next();
while (iter !== undefined) {
let tmp94 = nextResult;
if (nextResult.isSpacer) {
if (self.props.disableVirtualization) {
// continue
} else {
let tmp49 = nextResult;
let tmp50 = tmp37;
if (tmp94 === tmp38) {
if (!self.props.getItemLayout) {
let tmp51 = callback;
let tmp52 = closure_3;
let tmp54 = nextResult;
let _listMetrics = self._listMetrics;
let tmp53 = callback(closure_3[22]);
let diff = tmp94.first - 1;
let last = tmp53(diff, tmp94.last, _listMetrics.getHighestMeasuredCellIndex());
}
let _listMetrics2 = self._listMetrics;
let tmp57 = nextResult;
let _listMetrics3 = self._listMetrics;
let cellMetricsApprox = _listMetrics2.getCellMetricsApprox(tmp94.first, self.props);
let cellMetricsApprox1 = _listMetrics3.getCellMetricsApprox(last, self.props);
let tmp59 = items;
let tmp60 = callback8;
let tmp61 = closure_20;
let obj2 = {};
let tmp62 = callback2;
let tmp63 = _getSpacerKeyResult;
obj2.style = callback2({}, _getSpacerKeyResult, cellMetricsApprox1.offset + cellMetricsApprox1.length - cellMetricsApprox.offset);
let _HermesInternal = HermesInternal;
let arr2 = items.push(callback8(closure_20, obj2, "$spacer-" + tmp94.first));
}
let tmp56 = nextResult;
last = tmp94.last;
}
} else {
let tmp42 = items;
let tmp43 = items1;
let tmp44 = set;
let tmp45 = nextResult;
let tmp46 = null;
let tmp47 = self;
let _pushCellsResult = self._pushCells(items, items1, obj1, tmp94.first, tmp94.last, tmp8);
// continue
}
continue;
}
if (tmp65) {
const _console = console;
console.warn("VirtualizedList: missing keys for items, make sure to specify a key or id property on each item or provide a custom keyExtractor.", closure_25);
self._hasWarned.keys = true;
}
const tmp38 = tmp37;
const tmp65 = !self._hasWarned.keys && closure_24;
}
if (ListFooterComponent) {
let tmp69 = ListFooterComponent;
if (!callback6(ListFooterComponent)) {
tmp69 = callback8(ListFooterComponent, {});
}
const obj3 = { cellKey: self._getFooterCellKey() };
const obj4 = { onLayout: self._onLayoutFooter, style: closure_19.compose(tmp8, self.props.ListFooterComponentStyle), children: tmp69 };
obj3.children = callback8(closure_20, obj4);
items.push(callback8(VirtualizedList(closure_3[21]).VirtualizedListCellContextProvider, obj3, "$footer"));
}
const obj5 = {};
({ _onContentSizeChange: obj9.onContentSizeChange, _onLayout: obj9.onLayout, _onScroll: obj9.onScroll, _onScrollBeginDrag: obj9.onScrollBeginDrag, _onScrollEndDrag: obj9.onScrollEndDrag, _onMomentumScrollBegin: obj9.onMomentumScrollBegin, _onMomentumScrollEnd: obj9.onMomentumScrollEnd } = self);
const scrollEventThrottle = self.props.scrollEventThrottle;
let num8 = 0.0001;
if (null != scrollEventThrottle) {
num8 = scrollEventThrottle;
}
obj5.scrollEventThrottle = num8;
if (undefined !== self.props.invertStickyHeaders) {
let inverted = self.props.invertStickyHeaders;
} else {
inverted = self.props.inverted;
}
obj5.invertStickyHeaders = inverted;
obj5.stickyHeaderIndices = items1;
if (null) {
const items2 = [tmp8, self.props.style];
let style = items2;
} else {
style = self.props.style;
}
obj5.style = style;
obj5.isInvertedVirtualizedList = self.props.inverted;
let merged;
if (null != self.props.maintainVisibleContentPosition) {
const obj6 = {};
let num9 = 0;
if (self.props.ListHeaderComponent) {
num9 = 1;
}
obj6.minIndexForVisible = self.props.maintainVisibleContentPosition.minIndexForVisible + num9;
merged = Object.assign({}, self.props.maintainVisibleContentPosition, obj6);
}
obj5.maintainVisibleContentPosition = merged;
self._hasMore = self.state.cellsAroundViewport.last < itemCount - 1;
const merged1 = Object.assign({}, self.props, obj5);
const obj7 = {};
const obj8 = { cellKey: null, getScrollMetrics: self._getScrollMetrics, horizontal: VirtualizedList(closure_3[18]).horizontalOrDefault(self.props.horizontal) };
({ _getOutermostParentListRef: obj12.getOutermostParentListRef, _registerAsNestedChild: obj12.registerAsNestedChild, _unregisterAsNestedChild: obj12.unregisterAsNestedChild } = self);
obj7.value = obj8;
let _defaultRenderScrollComponent = self.props.renderScrollComponent;
if (!_defaultRenderScrollComponent) {
_defaultRenderScrollComponent = self._defaultRenderScrollComponent;
}
const obj9 = { ref: self._captureScrollRef };
obj7.children = closure_14(_defaultRenderScrollComponent(merged1), obj9, items);
const tmp83Result = callback8(VirtualizedList(closure_3[21]).VirtualizedListContextProvider, obj7);
let tmp88 = tmp83Result;
if (self.props.debug) {
const obj10 = { style: closure_26.debug };
const items3 = [tmp83Result, self._renderDebugOverlay()];
obj10.children = items3;
tmp88 = callback9(closure_20, obj10);
}
return tmp88;
} else {
obj = VirtualizedList(closure_3[18]);
obj.horizontalOrDefault(self.props.horizontal) ? closure_26.horizontallyInverted : closure_26.verticallyInverted;
}
}
};
items[22] = {
key: "componentDidUpdate",
value: function componentDidUpdate(data) {
const self = this;
const props = this.props;
let tmp2 = props.data === data.data;
if (tmp2) {
tmp2 = tmp === data.extraData;
}
if (!tmp2) {
const _viewabilityTuples = self._viewabilityTuples;
const item = _viewabilityTuples.forEach((viewabilityHelper) => {
viewabilityHelper = viewabilityHelper.viewabilityHelper;
viewabilityHelper.resetViewableIndices();
});
}
const result = self._scheduleCellsToRenderUpdate();
if (self._hiPriInProgress) {
self._hiPriInProgress = false;
}
if (null != props.getItemLayout) {
const result1 = self._maybeCallOnEdgeReached();
}
}
};
items[23] = {
key: "_computeBlankness",
value: function _computeBlankness() {
const _fillRateHelper = this._fillRateHelper;
const blankness = _fillRateHelper.computeBlankness(this.props, this.state.cellsAroundViewport, this._scrollMetrics);
}
};
items[24] = {
key: "_triggerRemeasureForChildListsInCell",
value: function _triggerRemeasureForChildListsInCell(tmp2Result) {
const _nestedChildLists = this._nestedChildLists;
_nestedChildLists.forEachInCell(tmp2Result, (measureLayoutRelativeToContainingList) => {
const result = measureLayoutRelativeToContainingList.measureLayoutRelativeToContainingList();
});
}
};
items[25] = {
key: "measureLayoutRelativeToContainingList",
value: function measureLayoutRelativeToContainingList() {
let _scrollRef;
let context;
const VirtualizedList = this;
if (this._scrollRef) {
({ _scrollRef, context } = this);
const outermostParentListRef = context.getOutermostParentListRef();
_scrollRef.measureLayout(outermostParentListRef.getScrollRef(), (arg0, arg1, width, height) => {
let _convertParentScrollMetrics;
let context;
let obj = { x: arg0, y: arg1 };
self._offsetFromParentVirtualizedList = self._selectOffset(obj);
const _listMetrics = self._listMetrics;
obj = { layout: obj, orientation: self._orientation() };
obj = { width, height };
const result = _listMetrics.notifyListContentLayout(obj);
({ context, _convertParentScrollMetrics } = self);
const result1 = _convertParentScrollMetrics(context.getScrollMetrics());
let tmp3 = self._scrollMetrics.visibleLength !== result1.visibleLength;
if (!tmp3) {
tmp3 = self._scrollMetrics.offset !== result1.offset;
}
if (tmp3) {
({ visibleLength: closure_0._scrollMetrics.visibleLength, offset: closure_0._scrollMetrics.offset } = result1);
const _nestedChildLists = self._nestedChildLists;
const item = _nestedChildLists.forEach((measureLayoutRelativeToContainingList) => {
const result = measureLayoutRelativeToContainingList.measureLayoutRelativeToContainingList();
});
}
}, (arg0) => {
console.warn("VirtualizedList: Encountered an error while measuring a list's offset from its containing VirtualizedList.");
});
}
}
};
items[26] = {
key: "_getFooterCellKey",
value: function _getFooterCellKey() {
return this._getCellKey() + "-footer";
}
};
items[27] = {
key: "_renderDebugOverlay",
value: function _renderDebugOverlay() {
const self = this;
const _listMetrics = this._listMetrics;
const result = this._scrollMetrics.visibleLength / (_listMetrics.getContentLength() || 1);
const VirtualizedList = result;
const items = [];
const props = self.props;
const itemCount = props.getItemCount(self.props.data);
for (let num = 0; num < itemCount; num = num + 1) {
let _listMetrics2 = self._listMetrics;
let cellMetricsApprox = _listMetrics2.getCellMetricsApprox(num, self.props);
let tmp5 = num;
if (cellMetricsApprox.isMounted) {
let arr = items.push(cellMetricsApprox);
}
}
const _listMetrics3 = self._listMetrics;
const offset = _listMetrics3.getCellMetricsApprox(self.state.cellsAroundViewport.first, self.props).offset;
const _listMetrics4 = self._listMetrics;
const cellMetricsApprox1 = _listMetrics4.getCellMetricsApprox(self.state.cellsAroundViewport.last, self.props);
const obj = { style: items1 };
const items1 = [closure_26.debugOverlayBase, closure_26.debugOverlay];
const diff = cellMetricsApprox1.offset + cellMetricsApprox1.length - offset;
const items2 = [
items.map((offset) => {
const style = [closure_26.debugOverlayBase, closure_26.debugOverlayFrame, { top: offset.offset * result, height: offset.length * result }];
return callback(closure_20, { style }, "f" + arg1);
}),
,
];
const items3 = [closure_26.debugOverlayBase, closure_26.debugOverlayFrameLast, { top: offset * result, height: diff * result }];
items2[1] = callback8(closure_20, { style: items3 });
const items4 = [closure_26.debugOverlayBase, closure_26.debugOverlayFrameVis, { top: self._scrollMetrics.offset * result, height: self._scrollMetrics.visibleLength * result }];
items2[2] = callback8(closure_20, { style: items4 });
obj.children = items2;
return callback9(closure_20, obj);
}
};
items[28] = {
key: "_selectLength",
value: function _selectLength(width) {
return VirtualizedList(closure_3[18]).horizontalOrDefault(this.props.horizontal) ? width.width : width.height;
}
};
items[29] = {
key: "_selectOffset",
value: function _selectOffset(arg0) {
let x;
let y;
({ y, x } = arg0);
if (this._orientation().horizontal) {
y = x;
}
return y;
}
};
items[30] = {
key: "_orientation",
value: function _orientation() {
const obj = { horizontal: VirtualizedList(closure_3[18]).horizontalOrDefault(this.props.horizontal), rtl: isRTL.isRTL };
return obj;
}
};
items[31] = {
key: "_maybeCallOnEdgeReached",
value: function _maybeCallOnEdgeReached() {
let data;
let getItemCount;
let offset;
let onEndReached;
let onEndReachedThreshold;
let onStartReached;
let onStartReachedThreshold;
let visibleLength;
const self = this;
const props = this.props;
({ onStartReached, onStartReachedThreshold, onEndReached, onEndReachedThreshold } = props);
const _listMetrics = this._listMetrics;
({ data, getItemCount } = props);
if (_listMetrics.hasContentLength()) {
if (0 !== self._scrollMetrics.visibleLength) {
if (self.state.pendingScrollUpdateCount <= 0) {
({ visibleLength, offset } = self._scrollMetrics);
const _listMetrics6 = self._listMetrics;
let num2 = _listMetrics6.getContentLength() - visibleLength - offset;
if (offset < 0.001) {
offset = 0;
}
if (num2 < 0.001) {
num2 = 0;
}
let num3 = 2;
let num4 = 2;
if (null != onStartReachedThreshold) {
num4 = onStartReachedThreshold * visibleLength;
}
if (null != onEndReachedThreshold) {
num3 = onEndReachedThreshold * visibleLength;
}
let tmp4 = onEndReached;
if (onEndReached) {
tmp4 = self.state.cellsAroundViewport.last === getItemCount(data) - 1;
}
if (tmp4) {
tmp4 = tmp3;
}
if (tmp4) {
const _listMetrics2 = self._listMetrics;
tmp4 = _listMetrics2.getContentLength() !== self._sentEndForContentLength;
}
if (tmp4) {
const _listMetrics3 = self._listMetrics;
self._sentEndForContentLength = _listMetrics3.getContentLength();
let obj = { distanceFromEnd: num2 };
onEndReached(obj);
}
let tmp6 = null != onStartReached && 0 === self.state.cellsAroundViewport.first && tmp2;
if (tmp6) {
const _listMetrics4 = self._listMetrics;
tmp6 = _listMetrics4.getContentLength() !== self._sentStartForContentLength;
}
if (tmp6) {
const _listMetrics5 = self._listMetrics;
self._sentStartForContentLength = _listMetrics5.getContentLength();
obj = { distanceFromStart: offset };
onStartReached(obj);
}
if (offset > num4) {
self._sentStartForContentLength = 0;
}
if (num2 > num3) {
self._sentEndForContentLength = 0;
}
}
}
}
}
};
items[32] = {
key: "_maybeScrollToInitialScrollIndex",
value: function _maybeScrollToInitialScrollIndex(width, height) {
const self = this;
let tmp = width > 0;
if (tmp) {
tmp = height > 0;
}
if (tmp) {
tmp = null != self.props.initialScrollIndex;
}
if (tmp) {
tmp = self.props.initialScrollIndex > 0;
}
if (tmp) {
tmp = !self._hasTriggeredInitialScrollToIndex;
}
if (tmp) {
if (null != self.props.contentOffset) {
self._hasTriggeredInitialScrollToIndex = true;
} else {
const props = self.props;
if (self.props.initialScrollIndex >= props.getItemCount(self.props.data)) {
let obj = { animated: false };
self.scrollToEnd(obj);
}
}
obj = { animated: false, index: callback(closure_3[23])(self.props.initialScrollIndex) };
self.scrollToIndex(obj);
}
}
};
items[33] = {
key: "unstable_onScroll",
value: function unstable_onScroll(arg0) {
this._onScroll(arg0);
}
};
items[34] = {
key: "_offsetFromScrollEvent",
value: function _offsetFromScrollEvent(nativeEvent) {
let contentOffset;
let contentSize;
let layoutMeasurement;
const self = this;
({ contentOffset, contentSize, layoutMeasurement } = nativeEvent.nativeEvent);
const _orientationResult = this._orientation();
if (_orientationResult.horizontal) {
if (_orientationResult.rtl) {
const _selectLengthResult = self._selectLength(contentSize);
let diff = _selectLengthResult - (self._selectOffset(contentOffset) + self._selectLength(layoutMeasurement));
const _selectOffsetResult = self._selectOffset(contentOffset);
}
return diff;
}
diff = self._selectOffset(contentOffset);
}
};
items[35] = {
key: "_scheduleCellsToRenderUpdate",
value: function _scheduleCellsToRenderUpdate() {
const self = this;
const VirtualizedList = this;
const _listMetrics = this._listMetrics;
if (_listMetrics.getAverageCellLength() > 0) {
if (self._shouldRenderWithPriority()) {
if (!self._hiPriInProgress) {
self._hiPriInProgress = true;
if (null != self._updateCellsToRenderTimeoutID) {
const _clearTimeout = clearTimeout;
clearTimeout(self._updateCellsToRenderTimeoutID);
self._updateCellsToRenderTimeoutID = null;
}
self._updateCellsToRender();
}
}
}
if (null == self._updateCellsToRenderTimeoutID) {
const updateCellsBatchingPeriod = self.props.updateCellsBatchingPeriod;
let num = 50;
if (null != updateCellsBatchingPeriod) {
num = updateCellsBatchingPeriod;
}
self._updateCellsToRenderTimeoutID = setTimeout(() => {
self._updateCellsToRenderTimeoutID = null;
self._updateCellsToRender();
}, num);
}
}
};
items[36] = {
key: "_shouldRenderWithPriority",
value: function _shouldRenderWithPriority() {
let first;
let last;
let offset;
let velocity;
let visibleLength;
const self = this;
({ first, last } = this.state.cellsAroundViewport);
({ offset, visibleLength, velocity } = this._scrollMetrics);
const props = this.props;
const itemCount = props.getItemCount(this.props.data);
const result = VirtualizedList(closure_3[18]).onStartReachedThresholdOrDefault(this.props.onStartReachedThreshold);
const obj = VirtualizedList(closure_3[18]);
let flag = false;
const result1 = VirtualizedList(closure_3[18]).onEndReachedThresholdOrDefault(this.props.onEndReachedThreshold);
if (first > 0) {
const _listMetrics = self._listMetrics;
const diff = offset - _listMetrics.getCellMetricsApprox(first, self.props).offset;
let tmp5 = diff < 0;
if (!tmp5) {
let tmp6 = velocity < -2;
if (tmp6) {
tmp6 = diff < callback11(result, visibleLength);
}
tmp5 = tmp6;
}
flag = tmp5;
}
let tmp8 = flag;
if (!flag) {
tmp8 = flag;
if (last >= 0) {
tmp8 = flag;
if (last < itemCount - 1) {
const _listMetrics2 = self._listMetrics;
const diff1 = _listMetrics2.getCellMetricsApprox(last, self.props).offset - (offset + visibleLength);
let tmp10 = diff1 < 0;
if (!tmp10) {
let tmp11 = velocity > 2;
if (tmp11) {
tmp11 = diff1 < callback11(result1, visibleLength);
}
tmp10 = tmp11;
}
tmp8 = tmp10;
}
}
}
return tmp8;
}
};
items[37] = {
key: "unstable_onScrollBeginDrag",
value: function unstable_onScrollBeginDrag(nativeEvent) {
this._onScrollBeginDrag(nativeEvent);
}
};
items[38] = {
key: "unstable_onScrollEndDrag",
value: function unstable_onScrollEndDrag(arg0) {
this._onScrollEndDrag(arg0);
}
};
items[39] = {
key: "unstable_onMomentumScrollBegin",
value: function unstable_onMomentumScrollBegin(arg0) {
const result = this._onMomentumScrollBegin(arg0);
}
};
items[40] = {
key: "unstable_onMomentumScrollEnd",
value: function unstable_onMomentumScrollEnd(nativeEvent) {
this._onMomentumScrollEnd(nativeEvent);
}
};
items[41] = {
key: "__getListMetrics",
value: function __getListMetrics() {
return this._listMetrics;
}
};
items[42] = {
key: "_updateViewableItems",
value: function _updateViewableItems(props, cellsAroundViewport) {
const VirtualizedList = props;
const self = this;
if (this.state.pendingScrollUpdateCount <= 0) {
const _viewabilityTuples = this._viewabilityTuples;
const item = _viewabilityTuples.forEach((viewabilityHelper) => {
viewabilityHelper = viewabilityHelper.viewabilityHelper;
viewabilityHelper.onUpdate(viewabilityHelper, self._scrollMetrics.offset, self._scrollMetrics.visibleLength, self._listMetrics, self._createViewToken, viewabilityHelper.onViewableItemsChanged, arg1);
});
}
}
};
const items1 = [
{
key: "_findItemIndexWithKey",
value: function _findItemIndexWithKey(getItemCount, firstVisibleItemKey, index) {
const itemCount = getItemCount.getItemCount(getItemCount.data);
if (null != index) {
if (index >= 0) {
if (index < itemCount) {
if (VirtualizedList._getItemKey(getItemCount, index) === firstVisibleItemKey) {
return index;
}
}
}
}
let num2 = 0;
if (0 < itemCount) {
while (VirtualizedList._getItemKey(getItemCount, num2) !== firstVisibleItemKey) {
num2 = num2 + 1;
}
return num2;
}
return null;
}
},
{
key: "_getItemKey",
value: function _getItemKey(props, index) {
return VirtualizedList._keyExtractor(props.getItem(props.data, index), index, props);
}
},
{
key: "_createRenderMask",
value: function _createRenderMask(getItemCount, _initialRenderRegionResult, closure_0) {
let items1 = closure_0;
const itemCount = getItemCount.getItemCount(getItemCount.data);
let tmp3 = _initialRenderRegionResult.first >= 0;
if (tmp3) {
tmp3 = _initialRenderRegionResult.last >= _initialRenderRegionResult.first - 1;
}
if (tmp3) {
tmp3 = _initialRenderRegionResult.last < itemCount;
}
callback(closure_3[13])(tmp3, "Invalid cells around viewport \"[" + _initialRenderRegionResult.first + ", " + _initialRenderRegionResult.last + "]\" was passed to VirtualizedList._createRenderMask");
const cellRenderMask = new VirtualizedList(closure_3[24]).CellRenderMask(itemCount);
if (itemCount > 0) {
const items = [_initialRenderRegionResult];
if (null == items1) {
items1 = [];
}
const combined = items.concat(closure_5(items1));
for (const item10047 of combined) {
let tmp8 = cellRenderMask;
let addCellsResult = obj.addCells(item10047);
}
if (null == getItemCount.initialScrollIndex) {
obj.addCells(VirtualizedList._initialRenderRegion(getItemCount));
}
const _Set = Set;
const set = new Set(getItemCount.stickyHeaderIndices);
const result = VirtualizedList._ensureClosestStickyHeader(getItemCount, set, obj, _initialRenderRegionResult.first);
const tmp22 = closure_5;
}
return cellRenderMask;
}
},
{
key: "_initialRenderRegion",
value: function _initialRenderRegion(getItemCount) {
const itemCount = getItemCount.getItemCount(getItemCount.data);
const initialScrollIndex = getItemCount.initialScrollIndex;
let num = 0;
const diff = itemCount - 1;
if (null != initialScrollIndex) {
num = initialScrollIndex;
}
const bound = Math.max(0, Math.min(diff, Math.floor(num)));
const obj = { first: bound, last: Math.min(itemCount, bound + VirtualizedList(closure_3[18]).initialNumToRenderOrDefault(getItemCount.initialNumToRender)) - 1 };
return obj;
}
},
{
key: "_ensureClosestStickyHeader",
value: function _ensureClosestStickyHeader(ListHeaderComponent, set, addCells, first) {
let num = 0;
if (ListHeaderComponent.ListHeaderComponent) {
num = 1;
}
let diff = first - 1;
if (diff >= 0) {
while (!set.has(diff + num)) {
diff = diff - 1;
}
const obj = { first: diff, last: diff };
addCells.addCells(obj);
}
}
},
{
key: "getDerivedStateFromProps",
value: function getDerivedStateFromProps(getItemCount, renderMask) {
const itemCount = getItemCount.getItemCount(getItemCount.data);
renderMask = renderMask.renderMask;
if (itemCount === renderMask.numCells()) {
return renderMask;
} else {
const firstVisibleItemKey = renderMask.firstVisibleItemKey;
const maintainVisibleContentPosition = getItemCount.maintainVisibleContentPosition;
let minIndexForVisible;
if (null != maintainVisibleContentPosition) {
minIndexForVisible = maintainVisibleContentPosition.minIndexForVisible;
}
let num = 0;
if (null != minIndexForVisible) {
num = minIndexForVisible;
}
let _getItemKeyResult = null;
if (getItemCount.getItemCount(getItemCount.data) > num) {
_getItemKeyResult = VirtualizedList._getItemKey(getItemCount, num);
}
let tmp5 = null;
if (null != getItemCount.maintainVisibleContentPosition) {
tmp5 = null;
if (null != firstVisibleItemKey) {
tmp5 = null;
if (null != _getItemKeyResult) {
tmp5 = null;
if (_getItemKeyResult !== firstVisibleItemKey) {
const renderMask2 = renderMask.renderMask;
const result = VirtualizedList._findItemIndexWithKey(getItemCount, firstVisibleItemKey, itemCount - renderMask2.numCells() + num);
let diff = null;
if (null != result) {
diff = result - num;
}
tmp5 = diff;
}
}
}
}
const cellsAroundViewport = renderMask.cellsAroundViewport;
if (null != tmp5) {
let obj = { first: cellsAroundViewport.first + tmp5, last: renderMask.cellsAroundViewport.last + tmp5 };
let tmp11 = obj;
} else {
tmp11 = cellsAroundViewport;
}
const result1 = VirtualizedList._constrainToItemCount(tmp11, getItemCount);
obj = { cellsAroundViewport: result1, renderMask: VirtualizedList._createRenderMask(getItemCount, result1), firstVisibleItemKey: _getItemKeyResult };
const pendingScrollUpdateCount = renderMask.pendingScrollUpdateCount;
if (null != tmp5) {
let sum = pendingScrollUpdateCount + 1;
} else {
sum = pendingScrollUpdateCount;
}
obj.pendingScrollUpdateCount = sum;
return obj;
}
}
},
{
key: "_constrainToItemCount",
value: function _constrainToItemCount(first, getItemCount) {
const diff = getItemCount.getItemCount(getItemCount.data) - 1;
let obj = VirtualizedList(closure_3[18]);
obj = {};
const bound = Math.max(0, diff - obj.maxToRenderPerBatchOrDefault(getItemCount.maxToRenderPerBatch));
obj.first = callback(closure_3[22])(0, first.first, bound);
obj.last = Math.min(diff, first.last);
return obj;
}
},
{
key: "_keyExtractor",
value: function _keyExtractor(item, sum, props) {
if (null != props.keyExtractor) {
return props.keyExtractor(item, sum);
} else {
const keyExtractorResult = VirtualizedList(closure_3[19]).keyExtractor(item, sum);
const _String = String;
if (keyExtractorResult === String(sum)) {
let closure_24 = true;
if (tmp5) {
const displayName = item.type.displayName;
}
const tmp5 = item.type && item.type.displayName;
}
return keyExtractorResult;
}
}
}
];
return callback(VirtualizedList, items, items1);
}(importDefault(dependencyMap[25]));
tmp5.contextType = arg1(dependencyMap[21]).VirtualizedListContext;
const items = [{ scale: -1 }];
const items1 = [{ scaleX: -1 }];
chore: update source for alpha 340.1
2026-07-21 06:55:02 +00:00
const styles = StyleSheet.create({ verticallyInverted: { transform: items }, horizontallyInverted: { transform: items1 }, debug: { flex: 1 }, debugOverlayBase: { "Null": 3375103, "Null": -8192, "Null": 4320799 }, debugOverlay: { <string:3470421188>: "getMediaKeyboardDraftType", <string:31327708>: "ackedDisclosures", <string:2880984030>: "FadeOutData", <string:1273248702>: "y" }, debugOverlayFrame: { -925468074: "y", -1811620922: "isArray" }, debugOverlayFrameLast: { 675631790: null, 206821628: null, 132697248: null }, debugOverlayFrameVis: {} });
chore: update source for alpha 340.0
2026-07-20 16:05:17 +00:00
export default tmp5;
Reference in a new issue Copy permalink