ecf26fc058
Skipped 1 file(s) >100MB (GitHub limit): source/__polyfill/04xxx/module_4823.js (118.4 MB)
2310 lines
84 KiB
TypeScript
2310 lines
84 KiB
TypeScript
// Module ID: 7182
|
|
// Function ID: 7183
|
|
// Name: FastList
|
|
// Dependencies: [109, 32, 19, 17, 21, 12, 558, 5675, 4634, 1364, 4374, 7183, 7184, 6735, 7185, 2]
|
|
// Exports: getItemSizeOverrideKey
|
|
|
|
// Module 7182 (FastList)
|
|
import _modDef12 from "module_12" /* 12 */;
|
|
import discord_common_shallowEqual from "discord_common/shallowEqual" /* 558 */;
|
|
import PlatformUtils from "PlatformUtils" /* 1364 */;
|
|
import ReanimatedRexport2 from "ReanimatedRexport" /* 4374 */;
|
|
import NativeViewDefault from "NativeView" /* 5675 */;
|
|
import BottomSheetModal from "BottomSheetModal" /* 6735 */;
|
|
import refObjectUnionAsPropDefault from "refObjectUnionAsProp" /* 7185 */;
|
|
import _objectWithoutProperties from "_objectWithoutProperties" /* 109 */;
|
|
import _slicedToArray from "module_32" /* 32 */;
|
|
import noop from "module_19" /* 19 */;
|
|
|
|
const discord_common_shallowEqualDefault = discord_common_shallowEqual;
|
|
const ReanimatedRexport = ReanimatedRexport2;
|
|
|
|
require = fn;
|
|
function renderDefaultEmpty() {
|
|
return null;
|
|
}
|
|
function defaultRecyclerKey() {
|
|
|
|
}
|
|
function FastListScrollWorklet(scrollViewRef) {
|
|
scrollViewRef = scrollViewRef.scrollViewRef;
|
|
const scrollPosValue = scrollViewRef.scrollPosValue;
|
|
const horizontal = scrollViewRef.horizontal;
|
|
const onScrollWorklet = scrollViewRef.onScrollWorklet;
|
|
const mutable = scrollViewRef(horizontal[10]).makeMutable(false);
|
|
obj = scrollViewRef(horizontal[10]);
|
|
const fn = function l(contentOffset) {
|
|
contentOffset = contentOffset.contentOffset;
|
|
const tmp2 = horizontal ? contentOffset.x : contentOffset.y;
|
|
const contentSize = contentOffset.contentSize;
|
|
const tmp3 = horizontal ? contentSize.width : contentSize.height;
|
|
if (0 !== tmp3) {
|
|
const result = mutable.set(true);
|
|
const _Math = Math;
|
|
const result1 = scrollPosValue.set(Math.min(tmp2, tmp3));
|
|
if (null != onScrollWorklet) {
|
|
const layoutMeasurement = contentOffset.layoutMeasurement;
|
|
tmp10(tmp2, tmp3, tmp ? layoutMeasurement.width : layoutMeasurement.height);
|
|
}
|
|
}
|
|
};
|
|
fn.__closure = { horizontal, workletMounted: mutable, scrollPosValue, onScrollWorklet };
|
|
fn.__workletHash = 16225357996403;
|
|
fn.__initData = __initData2;
|
|
const event = scrollViewRef(horizontal[10]).useEvent(fn, ["onScroll"]);
|
|
const items = [event, scrollViewRef];
|
|
const effect = noop.useEffect(() => {
|
|
const tmp = closure_1_9(scrollViewRef.current);
|
|
scrollViewRef = tmp;
|
|
if (null != tmp) {
|
|
event.workletEventHandler.registerForEvents(tmp);
|
|
return () => {
|
|
event.workletEventHandler.unregisterFromEvents(closure_0);
|
|
};
|
|
}
|
|
}, items);
|
|
return null;
|
|
}
|
|
let closure_3 = ["manualRef", "onScroll", "onScrollWorklet", "onScrollEnd", "onLayout", "renderHeader", "renderFooter", "renderSection", "renderItem", "renderSectionFooter", "getRecyclerKey", "onEndReached", "endReachedThreshold", "headerSize", "footerSize", "sectionSize", "sectionFooterSize", "itemSize", "sections", "scrollPosValue", "batchesToRender", "optimizeListItemRender", "initialScrollSection", "initialScrollItem", "initialScrollOrientation", "initialScrollStart", "getAnchorIdFromIndex", "getAnchorIndexFromId", "EXPERIMENTAL_enableAnchorWhileScrolling", "chunkBase", "disableContentWrappers", "childrenWrapper", "stickyHeaderFooter", "stickySectionsVariant", "persistantKeys", "disableRecyclingOnFullCompute", "disableLegacyGestureHandling", "viewabilityConfig", "onViewableItemsChanged", "debugLayout", "renderAccessory", "removeClippedSubviews", "inActionSheet"];
|
|
get_ActivityIndicator = fn(17);
|
|
({ PixelRatio: closure_7, ScrollView: closure_8, StyleSheet, findNodeHandle: closure_9 } = get_ActivityIndicator);
|
|
const jsxProd = fn(21);
|
|
({ jsxs: c10, jsx: closure_11, Fragment: closure_12 } = jsxProd);
|
|
let map = new Map();
|
|
const FastListItemTypes = { SPACER: "SPACER", HEADER: "HEADER", FOOTER: "FOOTER", SECTION: "SECTION", ITEM: "ITEM", SECTION_FOOTER: "SECTION_FOOTER" };
|
|
let FastListItemRecycler;
|
|
class FastListItemRecycler {
|
|
constructor(arg0) {
|
|
obj = Object.create(new.target.prototype);
|
|
closure_0 = obj;
|
|
obj._items = {};
|
|
obj._pendingItems = {};
|
|
item = global.forEach((recyclerKey) => {
|
|
_slicedToArray(obj._itemsForType(recyclerKey.type), 1)[0][recyclerKey.recyclerKey] = recyclerKey;
|
|
});
|
|
return obj;
|
|
}
|
|
}
|
|
const prototype = FastListItemRecycler.prototype;
|
|
prototype["_itemsForType"] = function _itemsForType(type) {
|
|
const self = this;
|
|
let tmp = this._items[type];
|
|
if (tmp == null) {
|
|
obj = {};
|
|
self._items[type] = obj;
|
|
tmp = obj;
|
|
}
|
|
const items = [tmp, ];
|
|
let tmp2 = self._pendingItems[type];
|
|
if (tmp2 == null) {
|
|
const items1 = [];
|
|
self._pendingItems[type] = items1;
|
|
tmp2 = items1;
|
|
}
|
|
items[1] = tmp2;
|
|
return items;
|
|
};
|
|
prototype["get"] = function get(type, layoutStart, layoutSize, customKey) {
|
|
let num = arg4;
|
|
if (arg4 === undefined) {
|
|
num = 0;
|
|
}
|
|
let num2 = arg5;
|
|
if (arg5 === undefined) {
|
|
num2 = -1;
|
|
}
|
|
const tmp = _slicedToArray(this._itemsForType(type), 2);
|
|
return this._get({ type, layoutStart, layoutSize, customKey, section: num, item: num2, items: tmp[0], pendingItems: tmp[1] });
|
|
};
|
|
prototype["_get"] = function _get(arg0) {
|
|
({ type, layoutStart, layoutSize, customKey, section, item, pendingItems } = arg0);
|
|
if (customKey == null) {
|
|
const _HermesInternal = HermesInternal;
|
|
customKey = "" + type + ":" + section + ":" + item;
|
|
}
|
|
if (null == arg0.items[customKey]) {
|
|
const obj2 = { type, key: -1, layoutStart, layoutSize, section, item, recyclerKey: customKey };
|
|
pendingItems.push(obj2);
|
|
obj = obj2;
|
|
} else {
|
|
obj = {};
|
|
const merged = Object.assign(tmp7);
|
|
obj.layoutStart = layoutStart;
|
|
obj.layoutSize = layoutSize;
|
|
obj.section = section;
|
|
obj.item = item;
|
|
delete tmp[tmp2];
|
|
}
|
|
return obj;
|
|
};
|
|
prototype["fill"] = function fill(arg0) {
|
|
const self = this;
|
|
closure_0 = arg0;
|
|
const item = self(12).forEach(obj, (type) => {
|
|
const tmp = _slicedToArray(self._itemsForType(type), 2);
|
|
self._fill(tmp[0], tmp[1], closure_0);
|
|
});
|
|
};
|
|
prototype["_fill"] = function _fill(arg0, arg1, arg2) {
|
|
let length;
|
|
let sum1;
|
|
closure_0 = arg1;
|
|
closure_1 = 0;
|
|
if (!arg2) {
|
|
const item = _modDef12.forEach(arg0, (arg0) => {
|
|
if (null == closure_0[closure_1]) {
|
|
return false;
|
|
} else {
|
|
tmp2.key = tmp;
|
|
closure_1 = closure_1 + 1;
|
|
}
|
|
});
|
|
}
|
|
if (closure_1 < arg1.length) {
|
|
do {
|
|
let sum = FastListItemRecycler._LAST_KEY + 1;
|
|
FastListItemRecycler._LAST_KEY = sum;
|
|
arg1[closure_1].key = sum;
|
|
sum1 = closure_1 + 1;
|
|
closure_1 = sum1;
|
|
length = arg1.length;
|
|
} while (sum1 < length);
|
|
}
|
|
arg1.length = 0;
|
|
};
|
|
FastListItemRecycler._LAST_KEY = 0;
|
|
class FastListComputer {
|
|
constructor(arg0) {
|
|
merged = Object.assign({ chunkSize: 0, uniform: false, dataCache: null, size: 0, dirty: true, lastStartChunk: -1, lastEndChunk: -1, items: null, persistantItemData: null, disableRecycling: false });
|
|
merged[2] = [];
|
|
merged[7] = [];
|
|
merged[8] = [];
|
|
merged.props = global;
|
|
updatePropsResult = merged.updateProps(global);
|
|
return merged;
|
|
}
|
|
}
|
|
const prototype2 = FastListComputer.prototype;
|
|
prototype2["updateProps"] = function updateProps(props) {
|
|
const self = this;
|
|
let dirty = this.dirty;
|
|
if (!dirty) {
|
|
dirty = !discord_common_shallowEqualDefault(props, self.props);
|
|
}
|
|
self.dirty = dirty;
|
|
self.props = props;
|
|
self.uniform = typeof props.itemSize === "number";
|
|
};
|
|
prototype2["setInfo"] = function setInfo(containerSize) {
|
|
const self = this;
|
|
const rounded = Math.ceil(containerSize / 4);
|
|
self.dirty = this.dirty || rounded !== self.chunkSize;
|
|
self.chunkSize = rounded;
|
|
};
|
|
prototype2["getSizeForHeader"] = function getSizeForHeader() {
|
|
const headerSize = this.props.headerSize;
|
|
let num = 0;
|
|
if (undefined !== headerSize) {
|
|
num = headerSize;
|
|
}
|
|
let numResult = num;
|
|
if (typeof num !== "number") {
|
|
numResult = num();
|
|
}
|
|
return numResult;
|
|
};
|
|
prototype2["getSizeForFooter"] = function getSizeForFooter() {
|
|
const footerSize = this.props.footerSize;
|
|
let num = 0;
|
|
if (undefined !== footerSize) {
|
|
num = footerSize;
|
|
}
|
|
let numResult = num;
|
|
if (typeof num !== "number") {
|
|
numResult = num();
|
|
}
|
|
return numResult;
|
|
};
|
|
prototype2["getSizeForSection"] = function getSizeForSection(arg0) {
|
|
const sectionSize = this.props.sectionSize;
|
|
let num = 0;
|
|
if (undefined !== sectionSize) {
|
|
num = sectionSize;
|
|
}
|
|
let numResult = num;
|
|
if (typeof num !== "number") {
|
|
numResult = num(arg0);
|
|
}
|
|
return numResult;
|
|
};
|
|
prototype2["getSizeForItem"] = function getSizeForItem(arg0, arg1) {
|
|
const itemSize = this.props.itemSize;
|
|
let itemSizeResult = itemSize;
|
|
if (typeof itemSize !== "number") {
|
|
itemSizeResult = itemSize(arg0, arg1);
|
|
}
|
|
return itemSizeResult;
|
|
};
|
|
prototype2["getSizeForSectionFooter"] = function getSizeForSectionFooter(arg0) {
|
|
const sectionFooterSize = this.props.sectionFooterSize;
|
|
let num = 0;
|
|
if (undefined !== sectionFooterSize) {
|
|
num = sectionFooterSize;
|
|
}
|
|
let numResult = num;
|
|
if (typeof num !== "number") {
|
|
numResult = num(arg0);
|
|
}
|
|
return numResult;
|
|
};
|
|
prototype2["getChunk"] = function getChunk(arg0) {
|
|
const self = this;
|
|
const dataCache = this.dataCache;
|
|
let diff = dataCache.length - 1;
|
|
if (null != this.chunkCache) {
|
|
if (arg0 >= self.chunkCache.start) {
|
|
if (arg0 <= self.chunkCache.end) {
|
|
return self.chunkCache;
|
|
}
|
|
}
|
|
}
|
|
let num = 0;
|
|
if (0 <= diff) {
|
|
const sum = num + ((diff - num) / 2 | 0);
|
|
let diff1 = diff;
|
|
while (null != dataCache[sum]) {
|
|
if (arg0 >= tmp3.start) {
|
|
if (arg0 <= tmp3.end) {
|
|
self.chunkCache = tmp3;
|
|
return tmp3;
|
|
}
|
|
}
|
|
if (arg0 < tmp3.start) {
|
|
diff1 = sum - 1;
|
|
let sum1 = num;
|
|
diff = diff1;
|
|
num = sum1;
|
|
if (sum1 <= diff1) {
|
|
continue;
|
|
} else {
|
|
break;
|
|
}
|
|
break;
|
|
} else if (arg0 <= tmp3.end) {
|
|
break;
|
|
} else {
|
|
sum1 = sum + 1;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
prototype2["compute"] = function compute(lastStartChunk, lastEndChunk, arr) {
|
|
closure_0 = lastStartChunk;
|
|
closure_1 = lastEndChunk;
|
|
let flag = arg3;
|
|
if (arg3 === undefined) {
|
|
flag = false;
|
|
}
|
|
const self = this;
|
|
getRecyclerKey = undefined;
|
|
let items;
|
|
let obj3;
|
|
closure_6 = undefined;
|
|
function addInitialSection(section, layoutStart, layoutSize, layoutStart2) {
|
|
items.push(obj3.get(obj3.SECTION, layoutStart, layoutSize, getRecyclerKey(obj3.SECTION, section), section));
|
|
const sum = layoutStart + layoutSize;
|
|
if (sum < layoutStart2) {
|
|
closure_6 = closure_6 + 1;
|
|
items.push(obj.get(obj3.SPACER, sum, layoutStart2 - sum, undefined, 0, closure_6));
|
|
}
|
|
}
|
|
function isVisible(layoutStart, layoutSize) {
|
|
let tmp = !flag;
|
|
if (flag) {
|
|
let tmp5 = layoutStart >= closure_0 - layoutSize;
|
|
if (tmp5) {
|
|
tmp5 = layoutStart < closure_1;
|
|
}
|
|
tmp = tmp5;
|
|
}
|
|
return tmp;
|
|
}
|
|
if (this.dirty) {
|
|
self.fullCompute();
|
|
let flag2 = true;
|
|
} else {
|
|
flag2 = false;
|
|
if (lastStartChunk === self.lastStartChunk) {
|
|
flag2 = false;
|
|
if (lastEndChunk === self.lastEndChunk) {
|
|
obj = { size: null, items: null };
|
|
({ size: obj.size, items: obj.items } = self);
|
|
return obj;
|
|
}
|
|
}
|
|
}
|
|
({ stickyHeaderFooter, getRecyclerKey } = self.props);
|
|
if (undefined === getRecyclerKey) {
|
|
getRecyclerKey = defaultRecyclerKey;
|
|
}
|
|
self.lastStartChunk = lastStartChunk;
|
|
self.lastEndChunk = lastEndChunk;
|
|
map = new Map();
|
|
const iter = self.persistantItemData[Symbol.iterator]();
|
|
const nextResult = iter.next();
|
|
while (iter !== undefined) {
|
|
let tmp4 = nextResult;
|
|
let item1;
|
|
({ type, section } = nextResult);
|
|
if (nextResult.type === obj.ITEM) {
|
|
item1 = tmp4.item;
|
|
}
|
|
let recyclerKey = getRecyclerKey(type, section, item1);
|
|
if (null != recyclerKey) {
|
|
let result = map.set(tmp10, tmp4);
|
|
}
|
|
continue;
|
|
}
|
|
let rounded = Math.floor(lastStartChunk / self.chunkSize);
|
|
const bound = Math.max(Math.ceil(lastEndChunk / self.chunkSize), rounded);
|
|
let result1 = rounded * self.chunkSize;
|
|
items = [];
|
|
self.items = items;
|
|
obj3 = new FastListItemRecycler(arr);
|
|
section2 = -1;
|
|
let num = -1;
|
|
section3 = -1;
|
|
closure_6 = 0;
|
|
const set = new Set();
|
|
if (rounded <= bound) {
|
|
do {
|
|
let chunk = self.getChunk(rounded);
|
|
if (null != chunk) {
|
|
let addResult = set.add(chunk);
|
|
}
|
|
rounded = rounded + 1;
|
|
} while (rounded <= bound);
|
|
}
|
|
for (const item10103 of set) {
|
|
if (null != item10103) {
|
|
let data = tmp21.data;
|
|
for (const item10107 of data) {
|
|
let tmp23 = item10107;
|
|
if (item10107.layoutStart + item10107.layoutSize >= result1) {
|
|
let type4 = tmp23.type;
|
|
let tmp224 = obj;
|
|
if (obj.HEADER === type4) {
|
|
if (isVisible(tmp23.layoutStart, tmp23.layoutSize)) {
|
|
arr = items.push(obj3.get(tmp224.HEADER, tmp23.layoutStart, tmp23.layoutSize, undefined));
|
|
}
|
|
result1 = tmp23.layoutStart + tmp23.layoutSize;
|
|
} else if (tmp224.SECTION === type4) {
|
|
if (isVisible(tmp23.layoutStart, tmp23.layoutSize)) {
|
|
if (-1 === section2) {
|
|
({ section: section2, section: section3 } = tmp23);
|
|
} else {
|
|
section3 = tmp23.section;
|
|
}
|
|
let recyclerKey1 = getRecyclerKey(tmp224.SECTION, tmp23.section);
|
|
let tmp104 = recyclerKey1;
|
|
let hasItem = null != recyclerKey1;
|
|
if (hasItem) {
|
|
hasItem = map.has(tmp104);
|
|
}
|
|
if (hasItem) {
|
|
let deleteResult = map.delete(tmp104);
|
|
}
|
|
let arr2 = items.push(obj3.get(tmp224.SECTION, tmp23.layoutStart, tmp23.layoutSize, tmp104, tmp23.section));
|
|
}
|
|
result1 = tmp23.layoutStart + tmp23.layoutSize;
|
|
} else if (tmp224.ITEM === type4) {
|
|
if (null == tmp23.uniform) {
|
|
if (isVisible(tmp23.layoutStart, tmp23.layoutSize)) {
|
|
if (0 === items.length) {
|
|
let addInitialSectionResult = addInitialSection(tmp23.section, tmp23.sectionData.layoutStart, tmp23.sectionData.layoutSize, tmp23.layoutStart);
|
|
}
|
|
if (-1 === section2) {
|
|
section2 = tmp23.section;
|
|
}
|
|
if (-1 === num) {
|
|
num = tmp23.item;
|
|
}
|
|
({ section: section3, item } = tmp23);
|
|
let recyclerKey2 = getRecyclerKey(tmp224.ITEM, tmp23.section, tmp23.item);
|
|
let tmp86 = recyclerKey2;
|
|
let hasItem1 = null != recyclerKey2;
|
|
if (hasItem1) {
|
|
hasItem1 = map.has(tmp86);
|
|
}
|
|
if (hasItem1) {
|
|
let deleteResult1 = map.delete(tmp86);
|
|
}
|
|
let arr3 = items.push(obj3.get(tmp224.ITEM, tmp23.layoutStart, tmp23.layoutSize, tmp86, tmp23.section, tmp23.item));
|
|
}
|
|
result1 = tmp23.layoutStart + tmp23.layoutSize;
|
|
} else {
|
|
let num3 = 0;
|
|
if (result1 > tmp23.layoutStart) {
|
|
let _Math = Math;
|
|
num3 = Math.floor((result1 - tmp23.layoutStart) / tmp23.itemSize);
|
|
}
|
|
let sum2 = num3;
|
|
let sum = tmp23.layoutStart + tmp23.itemSize * num3;
|
|
result1 = sum;
|
|
if (sum < bound * self.chunkSize) {
|
|
if (sum2 < tmp23.items) {
|
|
while (true) {
|
|
if (isVisible(result1, tmp23.itemSize)) {
|
|
if (0 === items.length) {
|
|
let addInitialSectionResult1 = addInitialSection(tmp23.section, tmp23.sectionData.layoutStart, tmp23.sectionData.layoutSize, result1);
|
|
}
|
|
if (-1 === section2) {
|
|
section2 = tmp23.section;
|
|
}
|
|
if (-1 === num) {
|
|
num = sum2;
|
|
}
|
|
section3 = tmp23.section;
|
|
let tmp58 = obj;
|
|
let recyclerKey3 = getRecyclerKey(obj.ITEM, tmp23.section, sum2);
|
|
let tmp60 = recyclerKey3;
|
|
let hasItem2 = null != recyclerKey3;
|
|
if (hasItem2) {
|
|
hasItem2 = map.has(tmp60);
|
|
}
|
|
if (hasItem2) {
|
|
let deleteResult2 = map.delete(tmp60);
|
|
}
|
|
let arr4 = items.push(obj3.get(tmp58.ITEM, result1, tmp23.itemSize, tmp60, tmp23.section, sum2));
|
|
}
|
|
let sum1 = result1 + tmp23.itemSize;
|
|
result1 = sum1;
|
|
sum2 = sum2 + 1;
|
|
if (sum1 >= bound * self.chunkSize) {
|
|
break;
|
|
} else {
|
|
if (sum2 < tmp23.items) {
|
|
continue;
|
|
} else {
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else if (tmp224.SECTION_FOOTER === type4) {
|
|
if (isVisible(tmp23.layoutStart, tmp23.layoutSize)) {
|
|
if (0 === items.length) {
|
|
let addInitialSectionResult2 = addInitialSection(tmp23.section, tmp23.sectionData.layoutStart, tmp23.sectionData.layoutSize, tmp23.layoutStart);
|
|
}
|
|
let SECTION_FOOTER = tmp224.SECTION_FOOTER;
|
|
let layoutStart = tmp23.layoutStart;
|
|
let arr5 = items.push(obj3.get(SECTION_FOOTER, layoutStart, tmp23.layoutSize, getRecyclerKey(tmp224.SECTION_FOOTER, tmp23.section), tmp23.section));
|
|
}
|
|
result1 = tmp23.layoutStart + tmp23.layoutSize;
|
|
} else if (tmp224.FOOTER === type4) {
|
|
if (isVisible(tmp23.layoutStart, tmp23.layoutSize)) {
|
|
let arr6 = items.push(obj3.get(tmp224.FOOTER, tmp23.layoutStart, tmp23.layoutSize, undefined));
|
|
}
|
|
result1 = tmp23.layoutStart + tmp23.layoutSize;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
const items1 = [];
|
|
const items2 = [];
|
|
let num6 = 0;
|
|
let num7 = 0;
|
|
while (tmp121 !== undefined) {
|
|
let tmp124 = obj3(tmp122, 2);
|
|
[tmp125, tmp126] = tmp124;
|
|
let tmp127 = tmp126;
|
|
if (tmp126.section < section2) {
|
|
num6 = num6 + tmp127.layoutSize;
|
|
let items3 = [tmp125, tmp127];
|
|
let arr7 = items1.push(items3);
|
|
} else if (tmp127.section > section3) {
|
|
num7 = num7 + tmp127.layoutSize;
|
|
let items4 = [tmp125, tmp127];
|
|
let arr25 = items2.push(items4);
|
|
} else if (tmp127.type === obj.ITEM) {
|
|
if (tmp127.section === section2) {
|
|
if (tmp127.item < num) {
|
|
num6 = num6 + tmp127.layoutSize;
|
|
let items5 = [tmp125, tmp127];
|
|
let arr26 = items1.push(items5);
|
|
}
|
|
}
|
|
num7 = num7 + tmp127.layoutSize;
|
|
let items6 = [tmp125, tmp127];
|
|
let arr27 = items2.push(items6);
|
|
}
|
|
continue;
|
|
}
|
|
const first = items[0];
|
|
if (null != first) {
|
|
if (first.layoutStart > 0) {
|
|
const headerDataCache = self.headerDataCache;
|
|
const layoutStart5 = first.layoutStart;
|
|
let tmp148 = stickyHeaderFooter;
|
|
if (stickyHeaderFooter) {
|
|
tmp148 = null != headerDataCache;
|
|
}
|
|
if (tmp148) {
|
|
tmp148 = "HEADER" !== first.type;
|
|
}
|
|
let layoutStart2 = layoutStart5;
|
|
if (tmp148) {
|
|
if (layoutStart5 - headerDataCache.layoutStart - headerDataCache.layoutSize > 0) {
|
|
items.unshift(obj3.get(obj.SPACER, headerDataCache.layoutStart + headerDataCache.layoutSize, layoutStart5 - headerDataCache.layoutStart - headerDataCache.layoutSize, undefined, 0, 0));
|
|
}
|
|
items.unshift(obj3.get(obj.HEADER, headerDataCache.layoutStart, headerDataCache.layoutSize, undefined));
|
|
layoutStart2 = headerDataCache.layoutStart;
|
|
}
|
|
const _Math2 = Math;
|
|
const bound1 = Math.max(layoutStart2 - num6, 0);
|
|
for (const item10429 of items1) {
|
|
let tmp161 = obj3(item10429, 2);
|
|
[tmp162, tmp163] = tmp161;
|
|
({ type: type2, layoutStart: layoutStart3, layoutSize, section: section4 } = tmp163);
|
|
let item2;
|
|
if (tmp163.type === obj.ITEM) {
|
|
item2 = tmp164.item;
|
|
}
|
|
let arr30 = items.unshift(obj3.get(type2, layoutStart3, layoutSize, tmp162, section4, item2));
|
|
continue;
|
|
}
|
|
if (bound1 > 0) {
|
|
items.unshift(obj3.get(obj.SPACER, 0, bound1, undefined, 0, 1));
|
|
}
|
|
}
|
|
}
|
|
if (null != items[items.length - 1]) {
|
|
let size = tmp182.layoutStart + tmp182.layoutSize;
|
|
} else {
|
|
size = self.size;
|
|
}
|
|
if (size < self.size) {
|
|
const footerDataCache = self.footerDataCache;
|
|
if (stickyHeaderFooter) {
|
|
stickyHeaderFooter = null != footerDataCache;
|
|
}
|
|
if (stickyHeaderFooter) {
|
|
stickyHeaderFooter = "FOOTER" !== tmp182.type;
|
|
}
|
|
let sum3 = size;
|
|
if (stickyHeaderFooter) {
|
|
if (size < footerDataCache.layoutStart) {
|
|
items.push(obj3.get(obj.SPACER, size, footerDataCache.layoutStart + footerDataCache.layoutSize - size, undefined, 1, 0));
|
|
}
|
|
items.push(obj3.get(obj.FOOTER, footerDataCache.layoutStart, footerDataCache.layoutSize, undefined));
|
|
sum3 = footerDataCache.layoutStart + footerDataCache.layoutSize;
|
|
}
|
|
const sum4 = sum3 + num7;
|
|
if (sum4 < self.size) {
|
|
items.push(obj3.get(obj.SPACER, sum4, self.size - sum4, undefined, 1, 1));
|
|
}
|
|
for (const item10531 of items2) {
|
|
let tmp202 = obj3(item10531, 2);
|
|
[tmp203, tmp204] = tmp202;
|
|
({ type: type3, layoutStart: layoutStart4, layoutSize: layoutSize2, section: section5 } = tmp204);
|
|
let item3;
|
|
if (tmp204.type === obj.ITEM) {
|
|
item3 = tmp205.item;
|
|
}
|
|
let arr35 = items.push(obj3.get(type3, layoutStart4, layoutSize2, tmp203, section5, item3));
|
|
continue;
|
|
}
|
|
}
|
|
let disableRecycling = self.disableRecycling;
|
|
if (!disableRecycling) {
|
|
disableRecycling = self.props.disableRecyclingOnFullCompute && flag2;
|
|
const tmp218 = self.props.disableRecyclingOnFullCompute && flag2;
|
|
}
|
|
obj3.fill(disableRecycling);
|
|
return { size: self.size, items };
|
|
};
|
|
prototype2["fullCompute"] = function fullCompute() {
|
|
const self = this;
|
|
const props = this.props;
|
|
({ sections, insetStart } = props);
|
|
let num = 0;
|
|
if (undefined !== insetStart) {
|
|
num = insetStart;
|
|
}
|
|
const insetEnd = props.insetEnd;
|
|
let num2 = 0;
|
|
if (undefined !== insetEnd) {
|
|
num2 = insetEnd;
|
|
}
|
|
let getRecyclerKey = props.getRecyclerKey;
|
|
if (undefined === getRecyclerKey) {
|
|
getRecyclerKey = defaultRecyclerKey;
|
|
}
|
|
const set = new Set(self.props.persistantKeys);
|
|
self.persistantItemData = [];
|
|
const items = [];
|
|
self.dataCache = items;
|
|
self.chunkCache = undefined;
|
|
const chunkSize = self.chunkSize;
|
|
_require = num;
|
|
self.headerDataCache = undefined;
|
|
self.footerDataCache = undefined;
|
|
function pushData(arg0, arg1, type) {
|
|
closure_0 = closure_0 + (arg1 - arg0);
|
|
const bound = Math.max(Math.floor(arg0 / chunkSize), 0);
|
|
const bound1 = Math.max(Math.floor(arg1 / chunkSize) - 1, bound);
|
|
let chunk = self.getChunk(bound);
|
|
if (null == chunk) {
|
|
obj = { start: bound, end: bound1, data: [] };
|
|
items.push(obj);
|
|
chunk = obj;
|
|
}
|
|
if (type.type === obj.HEADER) {
|
|
tmp3.headerDataCache = type;
|
|
} else if (type.type === tmp7.FOOTER) {
|
|
tmp3.footerDataCache = type;
|
|
}
|
|
chunk.end = bound1;
|
|
const data = chunk.data;
|
|
data.push(type);
|
|
}
|
|
const sizeForHeader = self.getSizeForHeader();
|
|
if (sizeForHeader > 0) {
|
|
obj = { type: null, layoutStart: null, layoutSize: null };
|
|
obj.type = obj.HEADER;
|
|
obj.layoutStart = _require;
|
|
obj.layoutSize = sizeForHeader;
|
|
pushData(_require, _require + sizeForHeader, obj);
|
|
}
|
|
for (let num3 = 0; num3 < sections.length; num3 = num3 + 1) {
|
|
let tmp5 = sections[num3];
|
|
if (0 !== tmp5) {
|
|
let tmp32 = _require;
|
|
let sizeForSection = self.getSizeForSection(num3);
|
|
let obj2 = { type: null, layoutStart: null, layoutSize: null, section: null };
|
|
let tmp34 = obj;
|
|
obj2.type = obj.SECTION;
|
|
obj2.layoutStart = _require;
|
|
obj2.layoutSize = sizeForSection;
|
|
obj2.section = num3;
|
|
if (set.size > 0) {
|
|
let recyclerKey = getRecyclerKey(tmp34.SECTION, num3);
|
|
let tmp8 = null != recyclerKey && set.has(recyclerKey);
|
|
if (tmp8) {
|
|
let persistantItemData = self.persistantItemData;
|
|
let arr = persistantItemData.push(obj2);
|
|
let deleteResult = set.delete(recyclerKey);
|
|
}
|
|
}
|
|
let pushDataResult1 = pushData(tmp32, tmp32 + sizeForSection, obj2);
|
|
if (self.uniform) {
|
|
let sizeForItem = self.getSizeForItem(num3, 0);
|
|
let obj3 = { type: tmp34.ITEM, uniform: true, layoutStart: _require, itemSize: sizeForItem, layoutSize: sizeForItem * tmp5, section: num3, items: tmp5, sectionData: obj2 };
|
|
let pushDataResult2 = pushData(_require, _require + sizeForItem * tmp5, obj3);
|
|
let tmp12 = tmp34;
|
|
} else {
|
|
let num4 = 0;
|
|
tmp12 = tmp34;
|
|
if (0 < tmp5) {
|
|
do {
|
|
let sizeForItem1 = self.getSizeForItem(num3, num4);
|
|
let obj4 = { type: null, layoutStart: null, layoutSize: null, section: null, item: null, sectionData: null };
|
|
let tmp15 = obj;
|
|
obj4.type = obj.ITEM;
|
|
obj4.layoutStart = _require;
|
|
obj4.layoutSize = sizeForItem1;
|
|
obj4.section = num3;
|
|
obj4.item = num4;
|
|
obj4.sectionData = obj2;
|
|
let pushDataResult3 = pushData(_require, _require + sizeForItem1, obj4);
|
|
if (set.size > 0) {
|
|
let recyclerKey1 = getRecyclerKey(tmp15.ITEM, num3, num4);
|
|
let tmp19 = null != recyclerKey1 && set.has(recyclerKey1);
|
|
if (tmp19) {
|
|
let persistantItemData1 = self.persistantItemData;
|
|
let arr2 = persistantItemData1.push(obj4);
|
|
let deleteResult1 = set.delete(recyclerKey1);
|
|
}
|
|
}
|
|
num4 = num4 + 1;
|
|
tmp12 = tmp15;
|
|
} while (num4 < tmp5);
|
|
}
|
|
}
|
|
let sizeForSectionFooter = self.getSizeForSectionFooter(num3);
|
|
if (sizeForSectionFooter > 0) {
|
|
let obj5 = { type: tmp12.SECTION_FOOTER, layoutStart: _require, layoutSize: sizeForSectionFooter, section: num3, sectionData: obj2 };
|
|
let pushDataResult4 = pushData(_require, _require + sizeForSectionFooter, obj5);
|
|
}
|
|
}
|
|
}
|
|
const sizeForFooter = self.getSizeForFooter();
|
|
if (sizeForFooter > 0) {
|
|
const obj6 = { type: obj.FOOTER, layoutStart: _require, layoutSize: sizeForFooter };
|
|
pushData(_require, _require + sizeForFooter, obj6);
|
|
}
|
|
_require = _require + num2;
|
|
self.size = closure_7.roundToNearestPixel(_require);
|
|
self.dirty = false;
|
|
};
|
|
prototype2["getChunkDataFromSectionItem"] = function getChunkDataFromSectionItem(arg0, arg1) {
|
|
const self = this;
|
|
if (this.dirty) {
|
|
self.fullCompute();
|
|
}
|
|
const iter = self.dataCache[Symbol.iterator]();
|
|
const nextResult = iter.next();
|
|
while (iter !== undefined) {
|
|
let tmp3 = nextResult;
|
|
let data = nextResult.data;
|
|
for (const item10022 of data) {
|
|
let tmp6 = item10022;
|
|
let type = item10022.type;
|
|
if (obj.ITEM === type) {
|
|
if (null != arg1) {
|
|
if (true === tmp6.uniform) {
|
|
if (tmp6.section === arg0) {
|
|
if (arg1 > tmp6.items) {
|
|
obj.return();
|
|
iter.return();
|
|
} else {
|
|
obj.return();
|
|
iter.return();
|
|
return tmp3;
|
|
}
|
|
}
|
|
}
|
|
if (null == tmp6.uniform) {
|
|
if (tmp6.section === arg0) {
|
|
if (tmp6.item === arg1) {
|
|
obj.return();
|
|
iter.return();
|
|
return tmp3;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (tmp7.SECTION === type) {
|
|
if (tmp6.section > arg0) {
|
|
obj.return();
|
|
iter.return();
|
|
} else if (null != arg1) {
|
|
continue;
|
|
} else {
|
|
obj.return();
|
|
iter.return();
|
|
return tmp3;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
};
|
|
prototype2["getChunkIndexFromSectionItem"] = function getChunkIndexFromSectionItem(arg0) {
|
|
const self = this;
|
|
({ targetSection, targetItem, padBottom } = arg0);
|
|
if (padBottom === undefined) {
|
|
padBottom = 16;
|
|
}
|
|
const iter = arg0.chunk.data[Symbol.iterator]();
|
|
const nextResult = iter.next();
|
|
while (iter !== undefined) {
|
|
let tmp2 = nextResult;
|
|
let type = nextResult.type;
|
|
if (obj.ITEM === type) {
|
|
if (tmp2.section !== targetSection) {
|
|
continue;
|
|
} else {
|
|
if (null == targetItem) {
|
|
continue;
|
|
} else if (tmp2.uniform) {
|
|
if (targetItem >= tmp2.items) {
|
|
iter.return();
|
|
} else {
|
|
let sum = tmp2.layoutStart + tmp2.sectionData.layoutSize + tmp2.itemSize * targetItem;
|
|
let obj2 = { startIndex: null, endIndex: null };
|
|
let tmp22 = globalThis;
|
|
let _Math5 = Math;
|
|
obj2.startIndex = Math.floor(sum / self.chunkSize);
|
|
let _Math6 = Math;
|
|
obj2.endIndex = Math.floor((sum + tmp2.itemSize + padBottom) / self.chunkSize);
|
|
iter.return();
|
|
return obj2;
|
|
}
|
|
} else if (tmp2.item >= targetItem) {
|
|
iter.return();
|
|
} else if (tmp2.item !== targetItem) {
|
|
continue;
|
|
} else {
|
|
let obj3 = { startIndex: null, endIndex: null };
|
|
let tmp18 = globalThis;
|
|
let _Math3 = Math;
|
|
obj3.startIndex = Math.floor((tmp2.layoutStart - tmp2.sectionData.layoutSize) / self.chunkSize);
|
|
let _Math4 = Math;
|
|
obj3.endIndex = Math.floor((tmp2.layoutStart + tmp2.layoutSize + padBottom) / self.chunkSize);
|
|
iter.return();
|
|
return obj3;
|
|
}
|
|
continue;
|
|
}
|
|
continue;
|
|
} else {
|
|
if (tmp3.SECTION !== type) {
|
|
continue;
|
|
} else if (null != targetItem) {
|
|
continue;
|
|
} else if (targetSection < tmp2.section) {
|
|
iter.return();
|
|
} else if (targetSection === tmp2.section) {
|
|
obj = { startIndex: null, endIndex: null };
|
|
let tmp4 = globalThis;
|
|
let _Math = Math;
|
|
obj.startIndex = Math.floor(tmp2.layoutStart / self.chunkSize);
|
|
let _Math2 = Math;
|
|
obj.endIndex = Math.floor((tmp2.layoutStart + tmp2.layoutSize + padBottom) / self.chunkSize);
|
|
iter.return();
|
|
return obj;
|
|
}
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
};
|
|
prototype2["computeScrollPosition"] = function computeScrollPosition(arg0, arg1, arg2) {
|
|
if (null == arg2) {
|
|
const self = this;
|
|
if (this.dirty) {
|
|
self.fullCompute();
|
|
}
|
|
const dataCache = self.dataCache;
|
|
if (arg1 < 0) {
|
|
return { scrollPosition: 0, size: 0, sectionOffset: 0 };
|
|
} else {
|
|
const iter = dataCache[Symbol.iterator]();
|
|
while (iter !== undefined) {
|
|
let data = iter.next().data;
|
|
for (const item10020 of data) {
|
|
let tmp7 = item10020;
|
|
let type = item10020.type;
|
|
if (obj.ITEM === type) {
|
|
if (null != arg2) {
|
|
if (true === tmp7.uniform) {
|
|
if (tmp7.section === arg1) {
|
|
if (arg2 > tmp7.items) {
|
|
obj.return();
|
|
iter.return();
|
|
} else {
|
|
let obj3 = { scrollPosition: null, size: null, sectionOffset: null };
|
|
obj3.scrollPosition = tmp7.sectionData.layoutStart + tmp7.sectionData.layoutSize + tmp7.itemSize * arg2;
|
|
obj3.size = tmp7.itemSize;
|
|
let num4 = 0;
|
|
if (arg0) {
|
|
num4 = tmp7.sectionData.layoutSize;
|
|
}
|
|
obj3.sectionOffset = num4;
|
|
obj.return();
|
|
iter.return();
|
|
return obj3;
|
|
}
|
|
}
|
|
}
|
|
if (null == tmp7.uniform) {
|
|
if (tmp7.section === arg1) {
|
|
if (tmp7.item === arg2) {
|
|
let obj7 = { scrollPosition: null, size: null, sectionOffset: null };
|
|
({ layoutStart: obj4.scrollPosition, layoutSize: obj4.size } = tmp7);
|
|
let num3 = 0;
|
|
if (arg0) {
|
|
num3 = tmp7.sectionData.layoutSize;
|
|
}
|
|
obj7.sectionOffset = num3;
|
|
obj.return();
|
|
iter.return();
|
|
return obj7;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if (tmp8.SECTION === type) {
|
|
if (tmp7.section > arg1) {
|
|
obj.return();
|
|
iter.return();
|
|
} else {
|
|
if (null == arg2) {
|
|
if (tmp7.section === arg1) {
|
|
let obj8 = { scrollPosition: null, size: null, sectionOffset: 0 };
|
|
({ layoutStart: obj2.scrollPosition, layoutSize: obj2.size } = tmp7);
|
|
obj.return();
|
|
iter.return();
|
|
return obj8;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
prototype2["getSectionItemFromPosition"] = function getSectionItemFromPosition(arg0) {
|
|
obj = arg1;
|
|
if (arg1 === undefined) {
|
|
obj = map;
|
|
}
|
|
const self = this;
|
|
if (this.dirty) {
|
|
self.fullCompute();
|
|
}
|
|
let num = 0;
|
|
let num2 = 0;
|
|
const iter = self.items[Symbol.iterator]();
|
|
const nextResult = iter.next();
|
|
while (iter !== undefined) {
|
|
let tmp4 = nextResult;
|
|
let sum = nextResult.layoutStart + num;
|
|
let layoutSize = obj.get(nextResult.recyclerKey);
|
|
let tmp7 = layoutSize;
|
|
if (layoutSize == null) {
|
|
layoutSize = tmp4.layoutSize;
|
|
}
|
|
if (layoutSize > 0) {
|
|
if (arg0 >= sum) {
|
|
if (arg0 <= sum + tmp9) {
|
|
num2 = (arg0 - sum) / layoutSize;
|
|
let tmp = nextResult;
|
|
iter.return();
|
|
break;
|
|
}
|
|
let obj2 = { item: tmp, positionPercentage: num2 };
|
|
return obj2;
|
|
}
|
|
}
|
|
let num3 = 0;
|
|
if (null != tmp7) {
|
|
num3 = tmp7 - tmp4.layoutSize;
|
|
}
|
|
num = num + num3;
|
|
continue;
|
|
}
|
|
};
|
|
prototype2["setDisableRecycling"] = function setDisableRecycling(disableRecycling) {
|
|
this.disableRecycling = disableRecycling;
|
|
};
|
|
prototype2["getSize"] = function getSize() {
|
|
const self = this;
|
|
if (this.dirty) {
|
|
self.fullCompute();
|
|
}
|
|
return self.size;
|
|
};
|
|
prototype2["isDirty"] = function isDirty() {
|
|
return this.dirty;
|
|
};
|
|
const __initData = { code: "function FastListTsx1(){const{scrollPosValue,interpolate,inputRange,outputRange,horizontal}=this.__closure;const interpolatedValue=scrollPosValue!=null?interpolate(scrollPosValue.get(),inputRange,outputRange):null;return{transform:interpolatedValue!=null?[horizontal?{translateX:interpolatedValue}:{translateY:interpolatedValue}]:undefined};}" };
|
|
let closure_20 = noop.memo(function FastListStickySectionRendererComponent(children) {
|
|
({ layoutStart, layoutSize, horizontal } = children);
|
|
({ nextSectionLayoutPosition, scrollPosValue } = children);
|
|
({ fastListInstance, section, debug, recyclerKey } = children);
|
|
let items = [-1, 0];
|
|
const items1 = [0, 0];
|
|
items.push(layoutStart);
|
|
items1.push(0);
|
|
if (nextSectionLayoutPosition == null) {
|
|
nextSectionLayoutPosition = 0;
|
|
}
|
|
const diff = nextSectionLayoutPosition - layoutSize;
|
|
if (diff >= layoutStart) {
|
|
let num2 = 0;
|
|
if (obj.isAndroid()) {
|
|
num2 = -1;
|
|
}
|
|
items.push(diff, diff + 1);
|
|
items1.push(diff - layoutStart + num2, diff - layoutStart + num2);
|
|
obj = horizontal(items[9]);
|
|
} else {
|
|
items.push(layoutStart + 1);
|
|
items1.push(1);
|
|
}
|
|
class I {
|
|
constructor() {
|
|
obj = scrollPosValue;
|
|
interpolateResult = null;
|
|
if (null != scrollPosValue) {
|
|
tmp2 = closure_0;
|
|
tmp3 = closure_2;
|
|
obj2 = closure_0(closure_2[10]);
|
|
tmp4 = closure_2;
|
|
tmp5 = closure_3;
|
|
interpolateResult = obj2.interpolate(obj.get(), closure_2, closure_3);
|
|
}
|
|
if (null == interpolateResult) {
|
|
obj1 = { transform: null };
|
|
obj1.transform = undefined;
|
|
return obj1;
|
|
} else {
|
|
tmp6 = horizontal;
|
|
if (horizontal) {
|
|
obj6 = { translateX: null };
|
|
obj6.translateX = interpolateResult;
|
|
obj7 = obj6;
|
|
} else {
|
|
obj7 = { translateY: null };
|
|
obj7.translateY = interpolateResult;
|
|
}
|
|
items = [];
|
|
items[0] = obj7;
|
|
tmp7 = items;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
let obj2 = horizontal(items[10]);
|
|
I.__closure = { scrollPosValue, interpolate: horizontal(items[10]).interpolate, inputRange: items, outputRange: items1, horizontal };
|
|
I.__workletHash = 699810682881;
|
|
I.__initData = __initData;
|
|
const Children = noop.Children;
|
|
const animatedStyle = obj2.useAnimatedStyle(I);
|
|
const onlyResult = Children.only(children.children(section, fastListInstance, scrollPosValue, layoutStart));
|
|
let style;
|
|
let obj3 = { scrollPosValue, interpolate: horizontal(items[10]).interpolate, inputRange: items, outputRange: items1, horizontal };
|
|
let obj4 = noop;
|
|
const tmp12 = closure_10;
|
|
if (null != onlyResult) {
|
|
if ("props" in onlyResult) {
|
|
style = onlyResult.props.style;
|
|
}
|
|
}
|
|
const items2 = [style, , ];
|
|
let tmp15;
|
|
if (!horizontal) {
|
|
tmp15 = layoutSize;
|
|
}
|
|
const size = { zIndex: 10, position: "relative", height: tmp15, width: null };
|
|
let tmp16;
|
|
if (horizontal) {
|
|
tmp16 = layoutSize;
|
|
}
|
|
let obj5 = { style: items2, collapsable: false, children: null };
|
|
size.width = tmp16;
|
|
items2[1] = size;
|
|
items2[2] = animatedStyle;
|
|
let cloneElementResult;
|
|
if (null != onlyResult) {
|
|
const obj6 = { style: { flex: 1 } };
|
|
cloneElementResult = obj4.cloneElement(onlyResult, obj6);
|
|
}
|
|
const items3 = [cloneElementResult, false];
|
|
obj5.children = items3;
|
|
return tmp12(scrollPosValue(items[11]), obj5);
|
|
});
|
|
let closure_21 = noop.memo(function _FastListSectionRenderer(disableWrapper) {
|
|
({ layoutSize, children, fastListInstance, section, recyclerKey, horizontal } = disableWrapper);
|
|
if (disableWrapper.disableWrapper) {
|
|
if (!disableWrapper.debug) {
|
|
obj = { children: children(section, fastListInstance) };
|
|
return closure_1_11(closure_1_12, obj);
|
|
}
|
|
}
|
|
if (horizontal) {
|
|
const obj2 = { width: layoutSize };
|
|
let obj3 = obj2;
|
|
} else {
|
|
obj3 = { height: layoutSize };
|
|
}
|
|
const obj4 = { collapsable: false, style: obj3, preventClipping: true, children: null };
|
|
fastListInstance = children(section, fastListInstance);
|
|
section = [fastListInstance, false];
|
|
obj4.children = section;
|
|
closure_1_10(NativeViewDefault, obj4);
|
|
});
|
|
let closure_22 = noop.memo(function _FastListSectionFooterRenderer(disableWrapper) {
|
|
({ layoutSize, fastListInstance, children, section, recyclerKey, horizontal } = disableWrapper);
|
|
if (disableWrapper.disableWrapper) {
|
|
if (!disableWrapper.debug) {
|
|
obj = { children: children(section, fastListInstance) };
|
|
return closure_1_11(closure_1_12, obj);
|
|
}
|
|
}
|
|
if (horizontal) {
|
|
const obj2 = { width: layoutSize };
|
|
let obj3 = obj2;
|
|
} else {
|
|
obj3 = { height: layoutSize };
|
|
}
|
|
const obj4 = { collapsable: false, style: obj3, children: null };
|
|
children = children(section, fastListInstance);
|
|
section = [children, false];
|
|
obj4.children = section;
|
|
closure_1_10(NativeViewDefault, obj4);
|
|
});
|
|
let closure_23 = noop.memo(function _FastListItemRenderer(disableWrapper) {
|
|
({ layoutSize, children, section, fastListInstance, item, recyclerKey, horizontal } = disableWrapper);
|
|
if (disableWrapper.disableWrapper) {
|
|
if (!disableWrapper.debug) {
|
|
if (children != null) {
|
|
let childrenResult = children(section, item, fastListInstance);
|
|
}
|
|
}
|
|
return childrenResult;
|
|
}
|
|
if (horizontal) {
|
|
const obj2 = { width: layoutSize };
|
|
let style = obj2;
|
|
} else {
|
|
style = { height: layoutSize };
|
|
}
|
|
const obj3 = { collapsable: false, style, children: null };
|
|
let childrenResult1;
|
|
if (children != null) {
|
|
childrenResult1 = children(section, item, fastListInstance);
|
|
}
|
|
const items = [childrenResult1, false];
|
|
obj3.children = items;
|
|
childrenResult = closure_1_10(NativeViewDefault, obj3);
|
|
});
|
|
let closure_24 = noop.memo(function _FastListHeaderFooterRenderer(disableWrapper) {
|
|
({ layoutSize, children, fastListInstance, recyclerKey, horizontal } = disableWrapper);
|
|
if (disableWrapper.disableWrapper) {
|
|
if (!disableWrapper.debug) {
|
|
obj = { children: children(fastListInstance) };
|
|
return closure_1_11(closure_1_12, obj);
|
|
}
|
|
}
|
|
if (horizontal) {
|
|
const obj2 = { width: layoutSize };
|
|
let obj3 = obj2;
|
|
} else {
|
|
obj3 = { height: layoutSize };
|
|
}
|
|
const obj4 = { collapsable: false, style: obj3, preventClipping: true, children: null };
|
|
children = children(fastListInstance);
|
|
fastListInstance = [children, false];
|
|
obj4.children = fastListInstance;
|
|
closure_1_10(NativeViewDefault, obj4);
|
|
});
|
|
let closure_25 = noop.memo(function _FastListSpacer(layoutSize) {
|
|
layoutSize = layoutSize.layoutSize;
|
|
if (layoutSize.horizontal) {
|
|
obj = { width: layoutSize };
|
|
let style = obj;
|
|
} else {
|
|
style = { height: layoutSize };
|
|
}
|
|
return closure_1_11(NativeViewDefault, { collapsable: false, style });
|
|
});
|
|
let c26 = 1000;
|
|
let c27 = 0.5;
|
|
class FastListScrollAnchor {
|
|
constructor(arg0) {
|
|
merged = Object.assign({ isCustomAnchor: false });
|
|
merged.getScrollPosition = global;
|
|
return merged;
|
|
}
|
|
}
|
|
const prototype3 = FastListScrollAnchor.prototype;
|
|
prototype3["hasAnchor"] = function hasAnchor() {
|
|
return null != this.anchorId;
|
|
};
|
|
prototype3["cleanAnchor"] = function cleanAnchor(arg0) {
|
|
let flag = arg0;
|
|
if (arg0 === undefined) {
|
|
flag = false;
|
|
}
|
|
const self = this;
|
|
let isCustomAnchor = !flag;
|
|
if (!flag) {
|
|
isCustomAnchor = self.isCustomAnchor;
|
|
}
|
|
if (!isCustomAnchor) {
|
|
self.isCustomAnchor = false;
|
|
self.anchorId = undefined;
|
|
self.anchorOffset = undefined;
|
|
}
|
|
};
|
|
prototype3["handleUserScroll"] = function handleUserScroll() {
|
|
this.cleanAnchor(true);
|
|
};
|
|
prototype3["setCustomAnchor"] = function setCustomAnchor(getAnchorIdFromIndex, anchorOffset, section, item) {
|
|
const self = this;
|
|
this.isCustomAnchor = true;
|
|
this.anchorOffset = anchorOffset;
|
|
this.anchorId = getAnchorIdFromIndex(section, item);
|
|
if (null == this.anchorId) {
|
|
self.cleanAnchor(true);
|
|
}
|
|
};
|
|
prototype3["findOrUpdateAnchor"] = function findOrUpdateAnchor(getAnchorIdFromIndex, items) {
|
|
const self = this;
|
|
const scrollPosition = this.getScrollPosition();
|
|
this.cleanAnchor();
|
|
const iter = items[Symbol.iterator]();
|
|
const nextResult = iter.next();
|
|
while (iter !== undefined) {
|
|
let tmp4 = nextResult;
|
|
if (nextResult.type === obj.ITEM) {
|
|
if (self.isCustomAnchor) {
|
|
let num = tmp4.item;
|
|
if (num == null) {
|
|
num = 0;
|
|
}
|
|
if (self.anchorId === getAnchorIdFromIndex(tmp4.section, num)) {
|
|
self.anchorOffset = nextResult.layoutStart - scrollPosition;
|
|
iter.return();
|
|
}
|
|
}
|
|
if (!self.isCustomAnchor) {
|
|
if (tmp4.layoutStart >= scrollPosition) {
|
|
self.anchorOffset = tmp4.layoutStart - scrollPosition;
|
|
({ item, section } = tmp4);
|
|
if (item == null) {
|
|
item = 0;
|
|
}
|
|
self.anchorId = getAnchorIdFromIndex(section, item);
|
|
iter.return();
|
|
}
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
};
|
|
prototype3["getAnchorIndex"] = function getAnchorIndex(getAnchorIndexFromId) {
|
|
const self = this;
|
|
if (null != this.anchorId) {
|
|
self.cleanAnchor();
|
|
return getAnchorIndexFromId(self.anchorId);
|
|
}
|
|
};
|
|
const PureComponent = noop.PureComponent;
|
|
class FastList extends PureComponent {
|
|
constructor(arg0) {
|
|
tmp1 = new tmp(global, tmp7, tmp6, tmp5, tmp4, tmp3, tmp2);
|
|
closure_0 = tmp1;
|
|
tmp1.containerSize = 0;
|
|
tmp1.scrollPos = 0;
|
|
obj2 = closure_0(closure_2[12]);
|
|
tmp1.scrollPosValue = obj2.createFakeSharedValue(0);
|
|
manualRef = tmp1.props.manualRef;
|
|
if (manualRef == null) {
|
|
tmp8 = closure_6;
|
|
manualRef = closure_6.createRef();
|
|
}
|
|
tmp1.scrollView = manualRef;
|
|
tmp1.getItems = function getItems() {
|
|
return closure_0.state.items;
|
|
};
|
|
tmp1.getScrollPosition = function getScrollPosition() {
|
|
return closure_0.scrollPos;
|
|
};
|
|
tmp1.disableAnchoringTimeout = undefined;
|
|
tmp1.deferredCompute = -1;
|
|
tmp1.deferNextCompute = false;
|
|
if (typeof FastListScrollAnchor === "function") {
|
|
merged = Object.assign({ isCustomAnchor: false });
|
|
merged.getScrollPosition = tmp9;
|
|
tmp1.scrollAnchor = merged;
|
|
tmp1.viewabilityDebounce = -1;
|
|
tmp1.previouslyViewableItems = [];
|
|
tmp1._scrollPositionToPoint = function _scrollPositionToPoint(initialScrollStart) {
|
|
const horizontal = closure_0.props.horizontal;
|
|
let num = 0;
|
|
if (horizontal) {
|
|
num = initialScrollStart;
|
|
}
|
|
const point = { x: num, y: null };
|
|
let num2 = 0;
|
|
if (!horizontal) {
|
|
num2 = initialScrollStart;
|
|
}
|
|
point.y = num2;
|
|
return point;
|
|
};
|
|
tmp1._calculateScrollPosition = function _calculateScrollPosition(paddingStart) {
|
|
({ itemCoords, orientation } = paddingStart);
|
|
if (orientation === undefined) {
|
|
orientation = "top";
|
|
}
|
|
let num = paddingStart.paddingStart;
|
|
if (num === undefined) {
|
|
num = 0;
|
|
}
|
|
let num2 = paddingStart.paddingEnd;
|
|
if (num2 === undefined) {
|
|
num2 = 0;
|
|
}
|
|
({ scrollPosition, size, sectionOffset } = itemCoords);
|
|
if (closure_0.containerSize > 0) {
|
|
let num3 = tmp.containerSize;
|
|
} else {
|
|
num3 = tmp.props.chunkBase;
|
|
if (num3 == null) {
|
|
num3 = 0;
|
|
}
|
|
}
|
|
if (size >= num3) {
|
|
orientation = "top";
|
|
}
|
|
if ("visible" === orientation) {
|
|
if (scrollPosition + sectionOffset >= tmp.scrollPos + num) {
|
|
if (scrollPosition + size <= tmp.scrollPos + (num3 - num2)) {
|
|
return null;
|
|
}
|
|
}
|
|
if (size <= num3) {
|
|
if (scrollPosition >= tmp.scrollPos) {
|
|
let diff = scrollPosition + size + num2 - num3;
|
|
}
|
|
}
|
|
diff = scrollPosition - (sectionOffset + num);
|
|
} else if ("top" === orientation) {
|
|
diff = scrollPosition - (sectionOffset + num);
|
|
} else {
|
|
diff = scrollPosition;
|
|
if ("center" === orientation) {
|
|
const _Math = Math;
|
|
const _Math2 = Math;
|
|
const sum = itemCoords.scrollPosition + Math.floor(itemCoords.size / 2);
|
|
diff = sum - Math.floor(num3 / 2);
|
|
}
|
|
}
|
|
return Math.max(0, Math.min(diff, paddingStart.fullSize - num3));
|
|
};
|
|
props = tmp1.props;
|
|
num = props.chunkBase;
|
|
obj1 = { headerSize: null, footerSize: null, sectionSize: null, itemSize: null, sectionFooterSize: null, sections: null, insetStart: null, insetEnd: null, stickyHeaderFooter: null, getRecyclerKey: null, persistantKeys: null, disableRecyclingOnFullCompute: null };
|
|
({ headerSize: obj3.headerSize, footerSize: obj3.footerSize, sectionSize: obj3.sectionSize, itemSize: obj3.itemSize, sectionFooterSize: obj3.sectionFooterSize, sections: obj3.sections, insetStart: obj3.insetStart, insetEnd: obj3.insetEnd, stickyHeaderFooter: obj3.stickyHeaderFooter, getRecyclerKey: obj3.getRecyclerKey, persistantKeys: obj3.persistantKeys, disableRecyclingOnFullCompute: obj3.disableRecyclingOnFullCompute } = props);
|
|
tmp11 = new.target;
|
|
if (typeof FastListComputer === "function") {
|
|
merged1 = Object.assign({ chunkSize: 0, uniform: false, dataCache: null, size: 0, dirty: true, lastStartChunk: -1, lastEndChunk: -1, items: null, persistantItemData: null, disableRecycling: false });
|
|
merged1[2] = [];
|
|
merged1[7] = [];
|
|
merged1[8] = [];
|
|
merged1.props = obj1;
|
|
updatePropsResult = merged1.updateProps(obj1);
|
|
if (num == null) {
|
|
num = 0;
|
|
}
|
|
flag = true;
|
|
tmp1.state = tmp1.getInitialState(num, merged1, true);
|
|
tmp1.handleViewabilityChange = function handleViewabilityChange() {
|
|
const onViewableItemsChanged = closure_0.props.onViewableItemsChanged;
|
|
if (null != onViewableItemsChanged) {
|
|
const items = tmp.state.items;
|
|
const sum = tmp.scrollPos + tmp.containerSize;
|
|
const items1 = [];
|
|
const iter = items[Symbol.iterator]();
|
|
const nextResult = iter.next();
|
|
while (iter !== undefined) {
|
|
let tmp5 = nextResult;
|
|
if (nextResult.layoutStart > sum) {
|
|
iter.return();
|
|
break;
|
|
} else {
|
|
let _Math = Math;
|
|
let bound = Math.max(tmp5.layoutStart, tmp22);
|
|
let _Math2 = Math;
|
|
let tmp8 = bound;
|
|
let bound1 = Math.min(tmp5.layoutStart + tmp5.layoutSize, sum);
|
|
if (bound < bound1) {
|
|
if ((tmp10 - tmp8) / tmp5.layoutSize >= tmp21) {
|
|
let arr = items1.push(tmp5.recyclerKey);
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
obj = discord_common_shallowEqual;
|
|
let tmp19 = closure_0;
|
|
if (!obj.areArraysShallowEqual(items1, closure_0.previouslyViewableItems)) {
|
|
tmp19.previouslyViewableItems = items1;
|
|
let result = onViewableItemsChanged(items1);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
tmp1.isVisible = function isVisible(arg0) {
|
|
let num = arg1;
|
|
if (arg1 === undefined) {
|
|
num = 0;
|
|
}
|
|
let num2 = arg2;
|
|
if (arg2 === undefined) {
|
|
num2 = 0;
|
|
}
|
|
return arg0 >= closure_0.scrollPos + num && arg0 <= closure_0.scrollPos + closure_0.containerSize - num2;
|
|
};
|
|
tmp1.scrollToTop = function scrollToTop() {
|
|
let flag = arg0;
|
|
if (arg0 === undefined) {
|
|
flag = true;
|
|
}
|
|
const scrollView = closure_0.scrollView;
|
|
if (scrollView != null) {
|
|
const current = scrollView.current;
|
|
if (current != null) {
|
|
const point = { x: 0, y: 0, animated: flag };
|
|
current.scrollTo(point);
|
|
}
|
|
}
|
|
};
|
|
tmp1.scrollToLocation = function scrollToLocation(orientation) {
|
|
({ section, item, animated } = orientation);
|
|
if (animated === undefined) {
|
|
animated = false;
|
|
}
|
|
let str = orientation.orientation;
|
|
if (str === undefined) {
|
|
str = "top";
|
|
}
|
|
let num = orientation.paddingStart;
|
|
if (num === undefined) {
|
|
num = 0;
|
|
}
|
|
let num2 = orientation.paddingEnd;
|
|
if (num2 === undefined) {
|
|
num2 = 0;
|
|
}
|
|
let flag = orientation.setAnchor;
|
|
if (flag === undefined) {
|
|
flag = false;
|
|
}
|
|
const current = closure_0.scrollView.current;
|
|
if (null == current) {
|
|
return false;
|
|
} else {
|
|
({ getAnchorIdFromIndex, stickySectionsVariant } = obj.props);
|
|
let str2 = "default";
|
|
if (undefined !== stickySectionsVariant) {
|
|
str2 = stickySectionsVariant;
|
|
}
|
|
const fastListComputer = obj.state.fastListComputer;
|
|
const scrollPosition = fastListComputer.computeScrollPosition("default" === str2, section, item);
|
|
if (null == scrollPosition) {
|
|
return false;
|
|
} else {
|
|
if ("visible" === str) {
|
|
if (obj.isVisible(scrollPosition.scrollPosition, num, num2)) {
|
|
return false;
|
|
}
|
|
}
|
|
const obj2 = { itemCoords: scrollPosition, fullSize: fastListComputer.getSize(), orientation: str, paddingStart: num, paddingEnd: num2 };
|
|
const result = obj._calculateScrollPosition(obj2);
|
|
let tmp3 = !animated;
|
|
if (!animated) {
|
|
tmp3 = flag;
|
|
}
|
|
if (tmp3) {
|
|
tmp3 = null != getAnchorIdFromIndex;
|
|
}
|
|
if (tmp3) {
|
|
const scrollAnchor = obj.scrollAnchor;
|
|
let num3 = result;
|
|
if (result == null) {
|
|
num3 = 0;
|
|
}
|
|
scrollAnchor.setCustomAnchor(getAnchorIdFromIndex, scrollPosition.scrollPosition - num3, section, item);
|
|
}
|
|
let flag2 = null != result && result !== obj.scrollPos;
|
|
if (flag2) {
|
|
if (!animated) {
|
|
obj.scrollPos = result;
|
|
const blocks = obj.computeBlocks();
|
|
}
|
|
const obj3 = {};
|
|
const merged = Object.assign(obj._scrollPositionToPoint(result));
|
|
obj3.animated = animated;
|
|
current.scrollTo(obj3);
|
|
flag2 = true;
|
|
}
|
|
return flag2;
|
|
}
|
|
}
|
|
};
|
|
tmp1.scrollTo = function scrollTo(initialScrollStart) {
|
|
let flag = arg1;
|
|
if (arg1 === undefined) {
|
|
flag = false;
|
|
}
|
|
const current = closure_0.scrollView.current;
|
|
const fastListComputer = closure_0.state.fastListComputer;
|
|
let tmp = null != current;
|
|
if (tmp) {
|
|
let flag2 = initialScrollStart <= fastListComputer.getSize() - obj.containerSize && initialScrollStart !== obj.scrollPos;
|
|
if (flag2) {
|
|
const obj2 = {};
|
|
const merged = Object.assign(obj._scrollPositionToPoint(initialScrollStart));
|
|
obj2.animated = flag;
|
|
current.scrollTo(obj2);
|
|
flag2 = true;
|
|
}
|
|
tmp = flag2;
|
|
}
|
|
return tmp;
|
|
};
|
|
tmp1.handleScroll = function handleScroll(nativeEvent) {
|
|
({ contentInset, horizontal, onScroll, onEndReached, endReachedThreshold, EXPERIMENTAL_enableAnchorWhileScrolling } = closure_0.props);
|
|
({ fastListComputer, hasReachedEndBefore } = closure_0.state);
|
|
const layoutMeasurement = nativeEvent.nativeEvent.layoutMeasurement;
|
|
const tmp2 = horizontal ? layoutMeasurement.width : layoutMeasurement.height;
|
|
let num = horizontal ? contentInset.left : contentInset.top;
|
|
if (num == null) {
|
|
num = 0;
|
|
}
|
|
let num2 = horizontal ? contentInset.right : contentInset.bottom;
|
|
if (num2 == null) {
|
|
num2 = 0;
|
|
}
|
|
closure_0.containerSize = tmp2 - num - num2;
|
|
const bound = Math.max(0, obj.getScrollPositionFromEvent(nativeEvent));
|
|
const bound1 = Math.min(bound, fastListComputer.getSize() - obj.containerSize);
|
|
closure_0.scrollPos = bound1;
|
|
if (onScroll != null) {
|
|
onScroll(nativeEvent);
|
|
}
|
|
if (closure_0.deferNextCompute) {
|
|
obj.deferNextCompute = false;
|
|
if (-1 !== obj.deferredCompute) {
|
|
const _cancelAnimationFrame = cancelAnimationFrame;
|
|
cancelAnimationFrame(obj.deferredCompute);
|
|
}
|
|
const _requestAnimationFrame = requestAnimationFrame;
|
|
obj.deferredCompute = requestAnimationFrame(() => closure_1_0.computeBlocks());
|
|
} else {
|
|
const blocks = obj.computeBlocks();
|
|
}
|
|
if (!tmp) {
|
|
const _clearTimeout = clearTimeout;
|
|
clearTimeout(obj.disableAnchoringTimeout);
|
|
const _setTimeout = setTimeout;
|
|
obj.disableAnchoringTimeout = setTimeout(() => {
|
|
clearTimeout(closure_1_0.disableAnchoringTimeout);
|
|
closure_1_0.disableAnchoringTimeout = undefined;
|
|
}, 100);
|
|
}
|
|
if (null != onEndReached) {
|
|
const contentSize = nativeEvent.nativeEvent.contentSize;
|
|
if (endReachedThreshold == null) {
|
|
endReachedThreshold = 0;
|
|
}
|
|
const rounded = Math.ceil((horizontal ? contentSize.width : contentSize.height) - endReachedThreshold - tmp2);
|
|
const _Math = Math;
|
|
const rounded1 = Math.ceil(bound1);
|
|
if (rounded1 >= rounded) {
|
|
if (!hasReachedEndBefore) {
|
|
obj.setState({ hasReachedEndBefore: true });
|
|
const obj2 = { distanceFromEnd: rounded1 - rounded };
|
|
onEndReached(obj2);
|
|
}
|
|
}
|
|
let tmp15 = !tmp12;
|
|
if (rounded1 < rounded) {
|
|
tmp15 = hasReachedEndBefore;
|
|
}
|
|
if (tmp15) {
|
|
obj.setState({ hasReachedEndBefore: false });
|
|
}
|
|
const tmp9 = horizontal ? contentSize.width : contentSize.height;
|
|
}
|
|
const result = obj.queueViewabilityChange();
|
|
};
|
|
tmp1.handleLayout = function handleLayout(nativeEvent) {
|
|
const state = closure_0.state;
|
|
const fastListComputer = state.fastListComputer;
|
|
({ contentInset, onLayout, horizontal, chunkBase } = closure_0.props);
|
|
const layout = nativeEvent.nativeEvent.layout;
|
|
let num = horizontal ? contentInset.left : contentInset.top;
|
|
if (num == null) {
|
|
num = 0;
|
|
}
|
|
let num2 = horizontal ? contentInset.right : contentInset.bottom;
|
|
if (num2 == null) {
|
|
num2 = 0;
|
|
}
|
|
closure_0.containerSize = (horizontal ? layout.width : layout.height) - num - num2;
|
|
if (null == chunkBase) {
|
|
fastListComputer.setInfo(obj.containerSize);
|
|
}
|
|
if (onLayout != null) {
|
|
onLayout(nativeEvent, obj);
|
|
}
|
|
if (state.isFirstLayout) {
|
|
if (null == chunkBase) {
|
|
obj.setState(obj.getInitialState(obj.containerSize, fastListComputer, false));
|
|
}
|
|
const result = obj.queueViewabilityChange();
|
|
}
|
|
const blocks = obj.computeBlocks();
|
|
};
|
|
tmp1.handleMomentumScrollEnd = function handleMomentumScrollEnd(arg0) {
|
|
const onScrollEnd = closure_0.props.onScrollEnd;
|
|
if (onScrollEnd != null) {
|
|
onScrollEnd(arg0);
|
|
}
|
|
};
|
|
tmp1.handleScrollBeginDrag = function handleScrollBeginDrag(arg0) {
|
|
const scrollAnchor = closure_0.scrollAnchor;
|
|
scrollAnchor.handleUserScroll();
|
|
const props = closure_0.props;
|
|
const onScrollBeginDrag = props.onScrollBeginDrag;
|
|
if (onScrollBeginDrag != null) {
|
|
onScrollBeginDrag(arg0);
|
|
}
|
|
};
|
|
props2 = tmp1.props;
|
|
({ getAnchorIdFromIndex, getAnchorIndexFromId } = props2);
|
|
num2 = 5;
|
|
if (props2.batchesToRender < 5) {
|
|
tmp29 = globalThis;
|
|
_Error4 = Error;
|
|
tmp30 = new.target;
|
|
str4 = "FastList: `batchesToRender` must be >= 6";
|
|
tmp31 = new.target;
|
|
error = new Error("FastList: `batchesToRender` must be >= 6");
|
|
tmp33 = error;
|
|
throw error;
|
|
} else {
|
|
if (null != getAnchorIdFromIndex) {
|
|
if (null != getAnchorIdFromIndex) {
|
|
}
|
|
tmp13 = globalThis;
|
|
_Error = Error;
|
|
tmp14 = new.target;
|
|
str = "FastList: You must define BOTH `getAnchorIndexFromId` and `getAnchorIdFromIndex`, or neither";
|
|
tmp15 = new.target;
|
|
error1 = new Error("FastList: You must define BOTH `getAnchorIndexFromId` and `getAnchorIdFromIndex`, or neither");
|
|
tmp17 = error1;
|
|
throw error1;
|
|
}
|
|
viewabilityConfig = tmp1.getViewabilityConfig();
|
|
if (viewabilityConfig.minimumViewTime <= 0) {
|
|
tmp24 = globalThis;
|
|
_Error3 = Error;
|
|
tmp25 = new.target;
|
|
str3 = "FastList: `viewabilityConfig.minimumViewTime` must be greater than 0";
|
|
tmp26 = new.target;
|
|
error2 = new Error("FastList: `viewabilityConfig.minimumViewTime` must be greater than 0");
|
|
tmp28 = error2;
|
|
throw error2;
|
|
} else {
|
|
if (viewabilityConfig.visibilityThreshold > 0) {
|
|
num3 = 1;
|
|
if (viewabilityConfig.visibilityThreshold <= 1) {
|
|
return tmp1;
|
|
}
|
|
}
|
|
tmp19 = globalThis;
|
|
_Error2 = Error;
|
|
tmp20 = new.target;
|
|
str2 = "FastList: `viewabilityConfig.visibilityThreshold` must be floating point value greater than 0 and less than 1";
|
|
tmp21 = new.target;
|
|
error3 = new Error("FastList: `viewabilityConfig.visibilityThreshold` must be floating point value greater than 0 and less than 1");
|
|
tmp23 = error3;
|
|
throw error3;
|
|
}
|
|
}
|
|
} else {
|
|
str6 = "Trying to call a non-function";
|
|
throw new TypeError("Trying to call a non-function");
|
|
}
|
|
} else {
|
|
str5 = "Trying to call a non-function";
|
|
throw new TypeError("Trying to call a non-function");
|
|
}
|
|
}
|
|
}
|
|
const prototype4 = FastList.prototype;
|
|
FastList["getDerivedStateFromProps"] = function getDerivedStateFromProps(headerSize, fastListComputer) {
|
|
fastListComputer = fastListComputer.fastListComputer;
|
|
fastListComputer.updateProps({ headerSize: headerSize.headerSize, footerSize: headerSize.footerSize, sectionSize: headerSize.sectionSize, itemSize: headerSize.itemSize, sectionFooterSize: headerSize.sectionFooterSize, sections: headerSize.sections, insetStart: headerSize.insetStart, insetEnd: headerSize.insetEnd, stickyHeaderFooter: headerSize.stickyHeaderFooter, getRecyclerKey: headerSize.getRecyclerKey, persistantKeys: headerSize.persistantKeys, disableRecyclingOnFullCompute: headerSize.disableRecyclingOnFullCompute });
|
|
if (0 === fastListComputer.batchSize) {
|
|
const obj2 = {};
|
|
const merged = Object.assign(fastListComputer);
|
|
let num = headerSize.insetStart;
|
|
if (num == null) {
|
|
num = 0;
|
|
}
|
|
let num2 = headerSize.insetEnd;
|
|
if (num2 == null) {
|
|
num2 = 0;
|
|
}
|
|
obj2.size = num + num2;
|
|
obj2.items = [];
|
|
let tmp3 = obj2;
|
|
} else {
|
|
tmp3 = null;
|
|
if (fastListComputer.isDirty()) {
|
|
const obj3 = {};
|
|
const merged1 = Object.assign(fastListComputer);
|
|
let items = fastListComputer.items;
|
|
({ blockStart, blockEnd } = fastListComputer);
|
|
if (items == null) {
|
|
items = [];
|
|
}
|
|
const merged2 = Object.assign(fastListComputer.compute(blockStart, blockEnd, items));
|
|
tmp3 = obj3;
|
|
}
|
|
}
|
|
return tmp3;
|
|
};
|
|
prototype4["computeScrollPosition"] = function computeScrollPosition(arg0, arg1) {
|
|
const fastListComputer = this.state.fastListComputer;
|
|
return fastListComputer.computeScrollPosition(false, arg0, arg1);
|
|
};
|
|
prototype4["getInitialState"] = function getInitialState(endImportTime, setInfo, isFirstLayout) {
|
|
let items = arg3;
|
|
if (arg3 === undefined) {
|
|
items = [];
|
|
}
|
|
const self = this;
|
|
const props = this.props;
|
|
({ batchesToRender, initialScrollSection } = props);
|
|
let num = 0;
|
|
if (undefined !== initialScrollSection) {
|
|
num = initialScrollSection;
|
|
}
|
|
({ initialScrollItem, initialScrollOrientation } = props);
|
|
let str = "visible";
|
|
if (undefined !== initialScrollOrientation) {
|
|
str = initialScrollOrientation;
|
|
}
|
|
({ initialScrollStart, stickySectionsVariant } = props);
|
|
let str2 = "default";
|
|
if (undefined !== stickySectionsVariant) {
|
|
str2 = stickySectionsVariant;
|
|
}
|
|
const horizontal = props.horizontal;
|
|
const scrollPosValue = props.scrollPosValue;
|
|
setInfo.setInfo(endImportTime);
|
|
let num2 = initialScrollStart;
|
|
if (initialScrollStart == null) {
|
|
num2 = 0;
|
|
}
|
|
if (null != initialScrollStart) {
|
|
let point = self._scrollPositionToPoint(initialScrollStart);
|
|
let tmp3 = num2;
|
|
} else if (num > 0) {
|
|
tmp3 = num2;
|
|
if (endImportTime > 0) {
|
|
const scrollPosition = setInfo.computeScrollPosition("default" === str2, num, initialScrollItem);
|
|
tmp3 = num2;
|
|
if (null != scrollPosition) {
|
|
obj = { itemCoords: scrollPosition, fullSize: setInfo.getSize(), orientation: str, paddingEnd: 16 };
|
|
const result = self._calculateScrollPosition(obj);
|
|
let diff = result;
|
|
if (result == null) {
|
|
diff = scrollPosition.scrollPosition - scrollPosition.sectionOffset;
|
|
}
|
|
tmp3 = diff;
|
|
if (null != result) {
|
|
point = self._scrollPositionToPoint(result);
|
|
tmp3 = diff;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
tmp3 = num2;
|
|
}
|
|
if (isFirstLayout) {
|
|
if (endImportTime > 0) {
|
|
if (0 === endImportTime) {
|
|
let obj2 = { batchSize: 0, blockStart: 0, blockEnd: 0 };
|
|
} else {
|
|
const _Math = Math;
|
|
const rounded = Math.ceil(endImportTime);
|
|
const _Math2 = Math;
|
|
const _Math3 = Math;
|
|
const rounded1 = Math.floor(tmp3);
|
|
const rounded2 = Math.ceil(rounded / 4);
|
|
const _Math4 = Math;
|
|
const _Math5 = Math;
|
|
const result1 = Math.max(0, Math.round((rounded1 + rounded / 2) / rounded2) - batchesToRender / 2) * rounded2;
|
|
obj2 = { batchSize: rounded2, blockStart: result1, blockEnd: result1 + rounded2 * batchesToRender };
|
|
}
|
|
({ batchSize, blockStart, blockEnd } = obj2);
|
|
}
|
|
}
|
|
const sum = tmp3 + endImportTime;
|
|
const rounded3 = Math.ceil(endImportTime / 4);
|
|
if (point == null) {
|
|
point = { x: 0, y: 0 };
|
|
}
|
|
const tmp10 = undefined !== horizontal && horizontal ? point.x : point.y;
|
|
self.scrollPos = tmp10;
|
|
if (null != scrollPosValue) {
|
|
const result2 = scrollPosValue.set(tmp10);
|
|
self.scrollPosValue = scrollPosValue;
|
|
} else {
|
|
self.scrollPosValue = ReanimatedRexport2.makeMutable(tmp10);
|
|
}
|
|
if (endImportTime > 0) {
|
|
let computeResult = setInfo.compute(tmp3, sum, items, true);
|
|
} else {
|
|
computeResult = { size: 0, items: [] };
|
|
}
|
|
const obj4 = {};
|
|
const merged = Object.assign(computeResult);
|
|
obj4.batchSize = rounded3;
|
|
obj4.blockStart = tmp3;
|
|
obj4.blockEnd = sum;
|
|
obj4.isFirstLayout = isFirstLayout;
|
|
obj4.fastListComputer = setInfo;
|
|
obj4.initialContentOffset = point;
|
|
obj4.hasReachedEndBefore = false;
|
|
return obj4;
|
|
};
|
|
prototype4["componentDidMount"] = function componentDidMount() {
|
|
const result = this.queueViewabilityChange();
|
|
};
|
|
prototype4["getSnapshotBeforeUpdate"] = function getSnapshotBeforeUpdate(getAnchorIdFromIndex, isFirstLayout) {
|
|
const self = this;
|
|
getAnchorIdFromIndex = getAnchorIdFromIndex.getAnchorIdFromIndex;
|
|
const EXPERIMENTAL_enableAnchorWhileScrolling = this.props.EXPERIMENTAL_enableAnchorWhileScrolling;
|
|
isFirstLayout = self.state.isFirstLayout;
|
|
if (tmp) {
|
|
let tmp4 = null == getAnchorIdFromIndex || isFirstLayout;
|
|
if (!tmp4) {
|
|
tmp4 = isFirstLayout !== isFirstLayout.isFirstLayout;
|
|
}
|
|
if (!tmp4) {
|
|
const scrollAnchor = self.scrollAnchor;
|
|
scrollAnchor.findOrUpdateAnchor(getAnchorIdFromIndex, isFirstLayout.items);
|
|
}
|
|
const scrollAnchor2 = self.scrollAnchor;
|
|
let tmp2 = scrollAnchor2.hasAnchor() || null;
|
|
const tmp7 = scrollAnchor2.hasAnchor() || null;
|
|
} else {
|
|
tmp2 = null;
|
|
}
|
|
return tmp2;
|
|
};
|
|
prototype4["componentDidUpdate"] = function componentDidUpdate(scrollPosValue, isFirstLayout, arg2) {
|
|
const self = this;
|
|
if (scrollPosValue.scrollPosValue !== this.props.scrollPosValue) {
|
|
const _Error = Error;
|
|
const error = new Error("FastList: scrollPosValue cannot changed after mounting");
|
|
throw error;
|
|
} else {
|
|
if (!self.state.isFirstLayout) {
|
|
if (isFirstLayout.isFirstLayout) {
|
|
if (null == self.props.chunkBase) {
|
|
const current = self.scrollView.current;
|
|
if (current != null) {
|
|
current.measure(() => self.restoreScrollPosition());
|
|
}
|
|
}
|
|
}
|
|
if (self.state.items !== isFirstLayout.items) {
|
|
const result = self.queueViewabilityChange();
|
|
}
|
|
}
|
|
if (arg2) {
|
|
self.anchorScroll();
|
|
}
|
|
}
|
|
};
|
|
prototype4["getViewabilityConfig"] = function getViewabilityConfig() {
|
|
const viewabilityConfig = this.props.viewabilityConfig;
|
|
let minimumViewTime;
|
|
if (viewabilityConfig != null) {
|
|
minimumViewTime = viewabilityConfig.minimumViewTime;
|
|
}
|
|
if (minimumViewTime == null) {
|
|
minimumViewTime = c26;
|
|
}
|
|
obj = { minimumViewTime, visibilityThreshold: null };
|
|
let visibilityThreshold;
|
|
if (viewabilityConfig != null) {
|
|
visibilityThreshold = viewabilityConfig.visibilityThreshold;
|
|
}
|
|
if (visibilityThreshold == null) {
|
|
visibilityThreshold = c27;
|
|
}
|
|
obj.visibilityThreshold = visibilityThreshold;
|
|
return obj;
|
|
};
|
|
prototype4["queueViewabilityChange"] = function queueViewabilityChange() {
|
|
const self = this;
|
|
if (null != this.props.onViewableItemsChanged) {
|
|
const _clearTimeout = clearTimeout;
|
|
clearTimeout(self.viewabilityDebounce);
|
|
const _setTimeout = setTimeout;
|
|
self.viewabilityDebounce = setTimeout(self.handleViewabilityChange, self.getViewabilityConfig().minimumViewTime);
|
|
}
|
|
};
|
|
prototype4["reset"] = function reset() {
|
|
const self = this;
|
|
let num = this.props.chunkBase;
|
|
const state = this.state;
|
|
({ fastListComputer, items } = state);
|
|
if (!state.isFirstLayout) {
|
|
({ setState, getInitialState } = self);
|
|
if (num == null) {
|
|
num = 0;
|
|
}
|
|
setState(getInitialState(num, fastListComputer, false, items));
|
|
}
|
|
};
|
|
prototype4["componentWillUnmount"] = function componentWillUnmount() {
|
|
const self = this;
|
|
if (-1 !== this.deferredCompute) {
|
|
const _cancelAnimationFrame = cancelAnimationFrame;
|
|
cancelAnimationFrame(self.deferredCompute);
|
|
}
|
|
if (-1 !== self.viewabilityDebounce) {
|
|
const _clearTimeout = clearTimeout;
|
|
clearTimeout(self.viewabilityDebounce);
|
|
}
|
|
};
|
|
prototype4["anchorScroll"] = function anchorScroll() {
|
|
const self = this;
|
|
({ getAnchorIndexFromId, stickySectionsVariant } = this.props);
|
|
let str = "default";
|
|
if (undefined !== stickySectionsVariant) {
|
|
str = stickySectionsVariant;
|
|
}
|
|
const fastListComputer = self.state.fastListComputer;
|
|
if (null != getAnchorIndexFromId) {
|
|
const anchorOffset = self.scrollAnchor.anchorOffset;
|
|
if (null != anchorOffset) {
|
|
const scrollAnchor = self.scrollAnchor;
|
|
const anchorIndex = scrollAnchor.getAnchorIndex(getAnchorIndexFromId);
|
|
if (null != anchorIndex) {
|
|
const scrollPosition = fastListComputer.computeScrollPosition("default" === str, anchorIndex.section, anchorIndex.item);
|
|
if (tmp3) {
|
|
self.scrollTo(scrollPosition.scrollPosition - anchorOffset);
|
|
}
|
|
tmp3 = null != scrollPosition && self.scrollPos !== scrollPosition.scrollPosition - anchorOffset;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
prototype4["getSectionItemFromPosition"] = function getSectionItemFromPosition(arg0, arg1) {
|
|
const fastListComputer = this.state.fastListComputer;
|
|
return fastListComputer.getSectionItemFromPosition(arg0, arg1);
|
|
};
|
|
prototype4["getScrollPositionFromEvent"] = function getScrollPositionFromEvent(nativeEvent) {
|
|
const contentOffset = nativeEvent.nativeEvent.contentOffset;
|
|
return this.props.horizontal ? contentOffset.x : contentOffset.y;
|
|
};
|
|
prototype4["restoreScrollPosition"] = function restoreScrollPosition() {
|
|
const self = this;
|
|
const props = this.props;
|
|
({ initialScrollItem, initialScrollSection } = props);
|
|
let num = 0;
|
|
if (undefined !== initialScrollSection) {
|
|
num = initialScrollSection;
|
|
}
|
|
const initialScrollOrientation = props.initialScrollOrientation;
|
|
let str = "visible";
|
|
if (undefined !== initialScrollOrientation) {
|
|
str = initialScrollOrientation;
|
|
}
|
|
const initialScrollStart = props.initialScrollStart;
|
|
if (null == initialScrollItem) {
|
|
if (num <= 0) {
|
|
if (null == initialScrollStart) {
|
|
const blocks = self.computeBlocks();
|
|
}
|
|
}
|
|
}
|
|
if (null != initialScrollStart) {
|
|
self.scrollTo(initialScrollStart, false);
|
|
} else {
|
|
obj = { section: num, item: null, orientation: null, paddingEnd: 16, setAnchor: true };
|
|
if (initialScrollItem == null) {
|
|
initialScrollItem = -1;
|
|
}
|
|
obj.item = initialScrollItem;
|
|
obj.orientation = str;
|
|
if (self.scrollToLocation(obj)) {
|
|
self.deferNextCompute = true;
|
|
} else {
|
|
const scrollPosValue = self.scrollPosValue;
|
|
const result = scrollPosValue.set(0);
|
|
if (-1 !== self.deferredCompute) {
|
|
const _cancelAnimationFrame = cancelAnimationFrame;
|
|
cancelAnimationFrame(self.deferredCompute);
|
|
}
|
|
const _requestAnimationFrame = requestAnimationFrame;
|
|
self.deferredCompute = requestAnimationFrame(() => self.computeBlocks());
|
|
}
|
|
}
|
|
};
|
|
prototype4["computeBlocks"] = function computeBlocks() {
|
|
const self = this;
|
|
({ batchesToRender, chunkBase } = this.props);
|
|
const state = this.state;
|
|
const fastListComputer = state.fastListComputer;
|
|
({ isFirstLayout, items } = state);
|
|
if (chunkBase == null) {
|
|
chunkBase = self.containerSize;
|
|
}
|
|
if (0 === chunkBase) {
|
|
obj = { batchSize: 0, blockStart: 0, blockEnd: 0 };
|
|
} else {
|
|
const _Math = Math;
|
|
const rounded = Math.ceil(chunkBase);
|
|
const _Math2 = Math;
|
|
const _Math3 = Math;
|
|
const rounded1 = Math.floor(tmp);
|
|
const rounded2 = Math.ceil(rounded / 4);
|
|
const _Math4 = Math;
|
|
const _Math5 = Math;
|
|
const result = Math.max(0, Math.round((rounded1 + rounded / 2) / rounded2) - batchesToRender / 2) * rounded2;
|
|
obj = { batchSize: rounded2, blockStart: result, blockEnd: result + rounded2 * batchesToRender };
|
|
}
|
|
if (obj.batchSize === self.state.batchSize) {
|
|
if (obj.blockStart === self.state.blockStart) {
|
|
if (obj.blockEnd === self.state.blockEnd) {
|
|
if (isFirstLayout) {
|
|
self.setState({ isFirstLayout: false });
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const obj2 = {};
|
|
const merged = Object.assign(obj);
|
|
const merged1 = Object.assign(fastListComputer.compute(obj.blockStart, obj.blockEnd, items));
|
|
obj2.isFirstLayout = false;
|
|
self.setState(obj2);
|
|
};
|
|
prototype4["renderItems"] = function renderItems() {
|
|
const self = this;
|
|
const props = this.props;
|
|
const stickySectionsVariant = props.stickySectionsVariant;
|
|
let str = "default";
|
|
if (undefined !== stickySectionsVariant) {
|
|
str = stickySectionsVariant;
|
|
}
|
|
let renderHeader = props.renderHeader;
|
|
if (undefined === renderHeader) {
|
|
renderHeader = renderDefaultEmpty;
|
|
}
|
|
let renderFooter = props.renderFooter;
|
|
if (undefined === renderFooter) {
|
|
renderFooter = renderDefaultEmpty;
|
|
}
|
|
let renderSection = props.renderSection;
|
|
if (undefined === renderSection) {
|
|
renderSection = renderDefaultEmpty;
|
|
}
|
|
const renderItem = props.renderItem;
|
|
let renderSectionFooter = props.renderSectionFooter;
|
|
if (undefined === renderSectionFooter) {
|
|
renderSectionFooter = renderDefaultEmpty;
|
|
}
|
|
const optimizeListItemRender = props.optimizeListItemRender;
|
|
const items = self.state.items;
|
|
let flag = self.props.horizontal;
|
|
if (flag == null) {
|
|
flag = false;
|
|
}
|
|
const items1 = [];
|
|
const item1 = items.forEach((type) => {
|
|
if (type.type === obj.SECTION) {
|
|
items1.push(tmp);
|
|
}
|
|
});
|
|
const items2 = [];
|
|
const iter = items[Symbol.iterator]();
|
|
const nextResult = iter.next();
|
|
while (iter !== undefined) {
|
|
({ type, key, layoutStart, recyclerKey, layoutSize } = nextResult);
|
|
let tmp5 = layoutSize;
|
|
({ section, item } = nextResult);
|
|
if (0 !== layoutSize) {
|
|
let tmp45 = obj;
|
|
if (obj.SPACER === type) {
|
|
let obj2 = { horizontal: flag, layoutSize: null };
|
|
obj2.layoutSize = tmp5;
|
|
let _HermesInternal7 = HermesInternal;
|
|
let arr = items2.push(closure_11(closure_25, obj2, "" + key));
|
|
} else if (tmp45.HEADER === type) {
|
|
let obj3 = { recyclerKey: null, horizontal: null, disableWrapper: null, fastListInstance: null, layoutSize: null, debug: false, children: null };
|
|
obj3.recyclerKey = recyclerKey;
|
|
obj3.horizontal = flag;
|
|
obj3.disableWrapper = tmp2;
|
|
obj3.fastListInstance = self;
|
|
obj3.layoutSize = tmp5;
|
|
let fn6 = renderHeader;
|
|
let tmp33 = closure_11;
|
|
let tmp34 = closure_24;
|
|
if (!tmp) {
|
|
fn6 = () => renderHeader(...HermesBuiltin.copyRestArgs());
|
|
}
|
|
obj3.children = fn6;
|
|
let _HermesInternal6 = HermesInternal;
|
|
let arr2 = items2.push(tmp33(tmp34, obj3, "" + key));
|
|
} else if (tmp45.FOOTER === type) {
|
|
let obj4 = { recyclerKey: null, horizontal: null, disableWrapper: null, fastListInstance: null, layoutSize: null, debug: false, children: null };
|
|
obj4.recyclerKey = recyclerKey;
|
|
obj4.horizontal = flag;
|
|
obj4.disableWrapper = tmp2;
|
|
obj4.fastListInstance = self;
|
|
obj4.layoutSize = tmp5;
|
|
let fn5 = renderFooter;
|
|
let tmp27 = closure_11;
|
|
let tmp28 = closure_24;
|
|
if (!tmp) {
|
|
fn5 = () => renderFooter(...HermesBuiltin.copyRestArgs());
|
|
}
|
|
obj4.children = fn5;
|
|
let _HermesInternal5 = HermesInternal;
|
|
let arr3 = items2.push(tmp27(tmp28, obj4, "" + key));
|
|
} else if (tmp45.SECTION === type) {
|
|
let arr11 = items1.shift();
|
|
if ("default" !== str) {
|
|
let obj5 = { recyclerKey: null, horizontal: null, disableWrapper: null, layoutStart: null, layoutSize: null, fastListInstance: null, section: null, debug: false, children: null };
|
|
obj5.recyclerKey = recyclerKey;
|
|
obj5.horizontal = flag;
|
|
obj5.disableWrapper = tmp2;
|
|
obj5.layoutStart = layoutStart;
|
|
obj5.layoutSize = tmp5;
|
|
obj5.fastListInstance = self;
|
|
obj5.section = section;
|
|
let fn4 = renderSection;
|
|
let tmp19 = closure_11;
|
|
let tmp20 = closure_21;
|
|
if (!tmp) {
|
|
fn4 = () => renderSection(...HermesBuiltin.copyRestArgs());
|
|
}
|
|
obj5.children = fn4;
|
|
let _HermesInternal4 = HermesInternal;
|
|
let arr12 = items2.push(tmp19(tmp20, obj5, "" + key));
|
|
} else {
|
|
let obj6 = { recyclerKey: null, horizontal: null, disableWrapper: null, layoutStart: null, layoutSize: null, nextSectionLayoutPosition: null, scrollPosValue: null, fastListInstance: null, section: null, debug: false, children: null };
|
|
obj6.recyclerKey = recyclerKey;
|
|
obj6.horizontal = flag;
|
|
obj6.disableWrapper = tmp2;
|
|
obj6.layoutStart = layoutStart;
|
|
obj6.layoutSize = tmp5;
|
|
obj6.nextSectionLayoutPosition = items1[0];
|
|
obj6.scrollPosValue = self.scrollPosValue;
|
|
obj6.fastListInstance = self;
|
|
obj6.section = section;
|
|
let fn3 = renderSection;
|
|
let tmp51 = closure_11;
|
|
let tmp52 = closure_20;
|
|
if (!tmp) {
|
|
fn3 = () => renderSection(...HermesBuiltin.copyRestArgs());
|
|
}
|
|
obj6.children = fn3;
|
|
let _HermesInternal3 = HermesInternal;
|
|
let arr13 = items2.push(tmp51(tmp52, obj6, "" + key));
|
|
}
|
|
} else if (tmp45.ITEM === type) {
|
|
obj = { recyclerKey: null, horizontal: null, disableWrapper: null, layoutSize: null, fastListInstance: null, section: null, item: null, debug: false, children: null };
|
|
obj.recyclerKey = recyclerKey;
|
|
obj.horizontal = flag;
|
|
obj.disableWrapper = tmp2;
|
|
obj.layoutSize = tmp5;
|
|
obj.fastListInstance = self;
|
|
obj.section = section;
|
|
obj.item = item;
|
|
let fn2 = renderItem;
|
|
let tmp8 = closure_11;
|
|
let tmp9 = closure_23;
|
|
if (!tmp) {
|
|
fn2 = () => renderItem(...HermesBuiltin.copyRestArgs());
|
|
}
|
|
obj.children = fn2;
|
|
let _HermesInternal2 = HermesInternal;
|
|
let arr14 = items2.push(tmp8(tmp9, obj, "" + key));
|
|
} else if (tmp45.SECTION_FOOTER === type) {
|
|
let obj7 = { recyclerKey: null, horizontal: null, disableWrapper: null, fastListInstance: null, layoutSize: null, section: null, debug: false, children: null };
|
|
obj7.recyclerKey = recyclerKey;
|
|
obj7.horizontal = flag;
|
|
obj7.disableWrapper = tmp2;
|
|
obj7.fastListInstance = self;
|
|
obj7.layoutSize = tmp5;
|
|
obj7.section = section;
|
|
let fn = renderSectionFooter;
|
|
let tmp46 = closure_11;
|
|
let tmp47 = closure_22;
|
|
if (!tmp) {
|
|
fn = () => renderSectionFooter(...HermesBuiltin.copyRestArgs());
|
|
}
|
|
obj7.children = fn;
|
|
let _HermesInternal = HermesInternal;
|
|
let arr15 = items2.push(tmp46(tmp47, obj7, "" + key));
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
return items2;
|
|
};
|
|
prototype4["isEmpty"] = function isEmpty() {
|
|
const sections = this.props.sections;
|
|
return 0 === sections.reduce((acc, item) => acc + item, 0);
|
|
};
|
|
prototype4["setDisableRecycling"] = function setDisableRecycling(arg0) {
|
|
const fastListComputer = this.state.fastListComputer;
|
|
fastListComputer.setDisableRecycling(arg0);
|
|
};
|
|
prototype4["render"] = function render() {
|
|
const self = this;
|
|
const props = this.props;
|
|
({ manualRef, onScroll, onScrollEnd, onLayout, renderHeader, renderFooter, renderSection, renderItem, renderSectionFooter, getRecyclerKey, onEndReached, endReachedThreshold, headerSize, footerSize, sectionSize, sectionFooterSize, itemSize, sections, scrollPosValue, batchesToRender, optimizeListItemRender, initialScrollSection, initialScrollItem, initialScrollOrientation, initialScrollStart, getAnchorIdFromIndex, getAnchorIndexFromId, EXPERIMENTAL_enableAnchorWhileScrolling, chunkBase, disableContentWrappers, childrenWrapper, stickyHeaderFooter, stickySectionsVariant, persistantKeys, disableRecyclingOnFullCompute, disableLegacyGestureHandling, viewabilityConfig, onViewableItemsChanged, debugLayout, renderAccessory, removeClippedSubviews } = props);
|
|
if (undefined === removeClippedSubviews) {
|
|
removeClippedSubviews = PlatformUtils.isAndroid();
|
|
}
|
|
if (props.inActionSheet) {
|
|
let BottomSheetScrollView = BottomSheetModal.BottomSheetScrollView;
|
|
} else {
|
|
BottomSheetScrollView = React6;
|
|
}
|
|
const obj3 = {};
|
|
const merged = Object.assign(_objectWithoutProperties(props, closure_3));
|
|
obj3.accessibilityRole = "list";
|
|
obj3.ref = refObjectUnionAsPropDefault(self.scrollView);
|
|
obj3.scrollEventThrottle = 16;
|
|
obj3.contentOffset = self.state.initialContentOffset;
|
|
({ handleScroll: obj2.onScroll, handleLayout: obj2.onLayout, handleMomentumScrollEnd: obj2.onMomentumScrollEnd, handleScrollBeginDrag: obj2.onScrollBeginDrag } = self);
|
|
obj3.removeClippedSubviews = removeClippedSubviews;
|
|
obj3.children = self.renderItems();
|
|
const children = [closure_1_11(BottomSheetScrollView, obj3), , ];
|
|
const obj5 = { scrollViewRef: self.scrollView, scrollPosValue: self.scrollPosValue, horizontal: null, onScrollWorklet: null };
|
|
let flag = self.props.horizontal;
|
|
if (flag == null) {
|
|
flag = false;
|
|
}
|
|
obj5.horizontal = flag;
|
|
obj5.onScrollWorklet = props.onScrollWorklet;
|
|
children[1] = closure_1_11(FastListScrollWorklet, obj5);
|
|
let renderAccessoryResult = null;
|
|
if (null != renderAccessory) {
|
|
renderAccessoryResult = renderAccessory(self);
|
|
}
|
|
children[2] = renderAccessoryResult;
|
|
return closure_1_10(closure_1_12, { children });
|
|
};
|
|
FastList.defaultProps = { batchesToRender: 12, contentInset: { top: 0, right: 0, left: 0, bottom: 0 }, disableLegacyGestureHandling: false, disableRecyclingOnFullCompute: false, stickyHeaderFooter: false };
|
|
const __initData2 = { code: "function FastListTsx2(event){const{horizontal,workletMounted,scrollPosValue,onScrollWorklet}=this.__closure;const scrollPosition=!horizontal?event.contentOffset.y:event.contentOffset.x;const contentSize=!horizontal?event.contentSize.height:event.contentSize.width;if(contentSize===0&&!workletMounted.get())return;workletMounted.set(true);scrollPosValue.set(Math.min(scrollPosition,contentSize));if(onScrollWorklet!=null){const layoutSize=!horizontal?event.layoutMeasurement.height:event.layoutMeasurement.width;onScrollWorklet(scrollPosition,contentSize,layoutSize);}}" };
|
|
const animatedComponent = ReanimatedRexport.createAnimatedComponent(FastList);
|
|
let size = fn(2);
|
|
let result = size.fileFinishedImporting("lib/native/FastList.tsx");
|
|
|
|
export default FastList;
|
|
export const DEFAULT_BATCHES_TO_RENDER = 12;
|
|
export const MINIMUM_BATCHES_TO_RENDER = 5;
|
|
export const getItemSizeOverrideKey = function getItemSizeOverrideKey(arg0, arg1, arg2) {
|
|
return "" + arg0 + ":" + arg1 + ":" + arg2;
|
|
};
|
|
export { FastListItemTypes };
|
|
export { FastListComputer };
|
|
export const AnimatedFastList = animatedComponent;
|