269 lines
8.4 KiB
JavaScript
269 lines
8.4 KiB
JavaScript
// Module ID: 310
|
|
// Function ID: 4759
|
|
// Name: _isViewable
|
|
// Dependencies: [57, 6, 7, 44]
|
|
|
|
// Module 310 (_isViewable)
|
|
import _slicedToArray from "_slicedToArray";
|
|
import _classCallCheck from "_classCallCheck";
|
|
import _defineProperties from "_defineProperties";
|
|
|
|
const require = arg1;
|
|
function _isViewable(arg0, arg1, arg2, arg3, arg4, arg5) {
|
|
if (tmp) {
|
|
return true;
|
|
} else {
|
|
const _Math = Math;
|
|
const _Math2 = Math;
|
|
const bound = Math.min(arg3, arg4);
|
|
const _Math3 = Math;
|
|
const bound1 = Math.max(0, bound - Math.max(arg2, 0));
|
|
if (arg0) {
|
|
let result = bound1 / arg4;
|
|
} else {
|
|
result = bound1 / arg5;
|
|
}
|
|
return 100 * result >= arg1;
|
|
}
|
|
tmp = arg2 >= 0 && arg3 <= arg4 && arg3 > arg2;
|
|
}
|
|
|
|
export default (() => {
|
|
class ViewabilityHelper {
|
|
constructor() {
|
|
self = this;
|
|
if (arguments.length > 0) {
|
|
if (undefined !== arguments[0]) {
|
|
first = arguments[0];
|
|
}
|
|
tmp2 = outer1_3;
|
|
tmp3 = ViewabilityHelper;
|
|
tmp4 = outer1_3(self, ViewabilityHelper);
|
|
flag = false;
|
|
self._hasInteracted = false;
|
|
tmp5 = globalThis;
|
|
_Set = Set;
|
|
prototype = Set.prototype;
|
|
tmp6 = new.target;
|
|
tmp7 = new.target;
|
|
set = new Set();
|
|
tmp9 = set;
|
|
self._timers = set;
|
|
self._viewableIndices = [];
|
|
_Map = Map;
|
|
prototype2 = Map.prototype;
|
|
tmp10 = new.target;
|
|
tmp11 = new.target;
|
|
map = new Map();
|
|
tmp13 = map;
|
|
self._viewableItems = map;
|
|
self._config = { viewAreaCoveragePercentThreshold: 0 };
|
|
return;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
let obj = {
|
|
key: "dispose",
|
|
value: function dispose() {
|
|
const _timers = this._timers;
|
|
const item = _timers.forEach(clearTimeout);
|
|
}
|
|
};
|
|
let items = [obj, , , , , ];
|
|
obj = {
|
|
key: "computeViewableItems",
|
|
value: function computeViewableItems(getItemCount, arg1, arg2, getCellMetrics, renderRange) {
|
|
let first;
|
|
let itemVisiblePercentThreshold;
|
|
let last;
|
|
let viewAreaCoveragePercentThreshold;
|
|
const itemCount = getItemCount.getItemCount(getItemCount.data);
|
|
({ itemVisiblePercentThreshold, viewAreaCoveragePercentThreshold } = this._config);
|
|
let tmp3 = itemVisiblePercentThreshold;
|
|
if (null != viewAreaCoveragePercentThreshold) {
|
|
tmp3 = viewAreaCoveragePercentThreshold;
|
|
}
|
|
let tmp5 = null != tmp3;
|
|
if (tmp5) {
|
|
tmp5 = null != itemVisiblePercentThreshold !== (null != viewAreaCoveragePercentThreshold);
|
|
}
|
|
ViewabilityHelper(outer1_1[3])(tmp5, "Must set exactly one of itemVisiblePercentThreshold or viewAreaCoveragePercentThreshold");
|
|
const items = [];
|
|
if (0 === itemCount) {
|
|
return items;
|
|
} else {
|
|
let tmp7 = renderRange;
|
|
if (!renderRange) {
|
|
let obj = { first: 0, last: itemCount - 1 };
|
|
tmp7 = obj;
|
|
}
|
|
({ first, last } = tmp7);
|
|
if (last >= itemCount) {
|
|
const _console = console;
|
|
const _JSON = JSON;
|
|
obj = { renderRange, itemCount };
|
|
console.warn(`Invalid render range computing viewability ${JSON.stringify(obj2)}`);
|
|
return [];
|
|
} else {
|
|
let num2 = -1;
|
|
if (first <= last) {
|
|
while (true) {
|
|
let cellMetrics = getCellMetrics.getCellMetrics(first, getItemCount);
|
|
let tmp8 = first;
|
|
let tmp9 = num2;
|
|
if (!cellMetrics) {
|
|
first = first + 1;
|
|
num2 = tmp9;
|
|
if (first > last) {
|
|
break;
|
|
}
|
|
} else {
|
|
let _Math = Math;
|
|
let rounded = Math.floor(cellMetrics.offset - arg1);
|
|
let _Math2 = Math;
|
|
let rounded1 = Math.floor(rounded + cellMetrics.length);
|
|
if (rounded < arg2) {
|
|
if (rounded1 > 0) {
|
|
let tmp14 = outer1_5;
|
|
let tmp15 = tmp2;
|
|
let tmp16 = tmp3;
|
|
let tmp17 = rounded;
|
|
let tmp18 = rounded1;
|
|
let tmp19 = arg2;
|
|
tmp9 = first;
|
|
let tmp20 = rounded;
|
|
let tmp21 = rounded1;
|
|
if (outer1_5(tmp2, tmp3, rounded, rounded1, arg2, cellMetrics.length)) {
|
|
let arr = items.push(first);
|
|
tmp9 = first;
|
|
let tmp23 = rounded;
|
|
let tmp24 = rounded1;
|
|
}
|
|
}
|
|
}
|
|
let tmp12 = rounded;
|
|
let tmp13 = rounded1;
|
|
tmp9 = num2;
|
|
if (num2 >= 0) {
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return items;
|
|
}
|
|
}
|
|
const tmp4 = ViewabilityHelper(outer1_1[3]);
|
|
}
|
|
};
|
|
items[1] = obj;
|
|
obj = {
|
|
key: "onUpdate",
|
|
value: function onUpdate(getItemCount, arg1, arg2, getCellMetrics, closure_1, _slicedToArray, renderRange) {
|
|
let self = this;
|
|
let closure_0 = getItemCount;
|
|
self = this;
|
|
const itemCount = getItemCount.getItemCount(getItemCount.data);
|
|
if (!this._config.waitForInteraction) {
|
|
if (0 !== itemCount) {
|
|
if (getCellMetrics.getCellMetrics(0, getItemCount)) {
|
|
let items = [];
|
|
let viewableItems = items;
|
|
if (itemCount) {
|
|
viewableItems = self.computeViewableItems(getItemCount, arg1, arg2, getCellMetrics, renderRange);
|
|
items = viewableItems;
|
|
}
|
|
if (self._viewableIndices.length !== items.length) {
|
|
self._viewableIndices = items;
|
|
if (self._config.minimumViewTime) {
|
|
const _setTimeout = setTimeout;
|
|
const timerId = setTimeout(() => {
|
|
const _timers = self._timers;
|
|
_timers.delete(timerId);
|
|
self._onUpdateSync(closure_0, viewableItems, _slicedToArray, closure_1);
|
|
}, self._config.minimumViewTime);
|
|
let _timers = self._timers;
|
|
_timers.add(timerId);
|
|
} else {
|
|
self._onUpdateSync(getItemCount, items, _slicedToArray, closure_1);
|
|
}
|
|
} else {
|
|
const _viewableIndices = self._viewableIndices;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
items[2] = obj;
|
|
items[3] = {
|
|
key: "resetViewableIndices",
|
|
value: function resetViewableIndices() {
|
|
this._viewableIndices = [];
|
|
}
|
|
};
|
|
items[4] = {
|
|
key: "recordInteraction",
|
|
value: function recordInteraction() {
|
|
this._hasInteracted = true;
|
|
}
|
|
};
|
|
items[5] = {
|
|
key: "_onUpdateSync",
|
|
value: function _onUpdateSync(closure_0, items, _slicedToArray, closure_1) {
|
|
let self = this;
|
|
self = this;
|
|
const found = items.filter((arg0) => {
|
|
const _viewableIndices = self._viewableIndices;
|
|
return _viewableIndices.includes(arg0);
|
|
});
|
|
const _viewableItems = this._viewableItems;
|
|
const map = new Map(found.map((arg0) => {
|
|
const tmp = callback(arg0, true, closure_0);
|
|
const items = [tmp.key, tmp];
|
|
return items;
|
|
}));
|
|
let obj = map;
|
|
items = [];
|
|
while (tmp3 !== undefined) {
|
|
let tmp5 = outer1_2;
|
|
let tmp6 = outer1_2(tmp4, 2);
|
|
let tmp7 = tmp6[1];
|
|
let tmp8 = _viewableItems;
|
|
if (!_viewableItems.has(tmp6[0])) {
|
|
let tmp9 = items;
|
|
let tmp10 = tmp7;
|
|
let arr = items.push(tmp7);
|
|
}
|
|
continue;
|
|
}
|
|
tmp3 = map[Symbol.iterator]();
|
|
while (tmp12 !== undefined) {
|
|
let tmp14 = outer1_2;
|
|
let tmp15 = outer1_2(tmp13, 2);
|
|
let tmp16 = tmp15[1];
|
|
let tmp17 = tmp2;
|
|
if (!obj.has(tmp15[0])) {
|
|
let tmp18 = items;
|
|
let _Object = Object;
|
|
let tmp19 = tmp16;
|
|
obj = { isViewable: false };
|
|
arr = items.push(Object.assign({}, tmp16, obj));
|
|
}
|
|
continue;
|
|
}
|
|
if (items.length > 0) {
|
|
self._viewableItems = obj;
|
|
obj = {};
|
|
const _Array = Array;
|
|
obj.viewableItems = Array.from(obj.values());
|
|
obj.changed = items;
|
|
obj.viewabilityConfig = self._config;
|
|
_slicedToArray(obj);
|
|
}
|
|
}
|
|
};
|
|
return callback(ViewabilityHelper, items);
|
|
})();
|