@tamagui/react-native-web-lite 2.7.7 → 3.0.0-beta.1091.1

package/dist/cjs/vendor/react-native/ViewabilityHelper.cjs

@@ -3,173 +3,163 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-  for (var name in all) __defProp(target, name, {
-    get: all[name],
-    enumerable: true
-  });
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
 };
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    });
-  }
-  return to;
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: () => from[key],
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
 };
-var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-  value: true
-}), mod);
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var ViewabilityHelper_exports = {};
 __export(ViewabilityHelper_exports, {
-  ViewabilityHelper: () => ViewabilityHelper,
-  default: () => ViewabilityHelper_default
+	ViewabilityHelper: () => ViewabilityHelper,
+	default: () => ViewabilityHelper_default
 });
 module.exports = __toCommonJS(ViewabilityHelper_exports);
 var import_react_native_web_internals = require("@tamagui/react-native-web-internals");
-class ViewabilityHelper {
-  _config;
-  _hasInteracted = false;
-  _timers = /* @__PURE__ */new Set();
-  _viewableIndices = [];
-  _viewableItems = /* @__PURE__ */new Map();
-  constructor(config = {
-    viewAreaCoveragePercentThreshold: 0
-  }) {
-    this._config = config;
-  }
-  /**
-   * Cleanup, e.g. on unmount. Clears any pending timers.
-   */
-  dispose() {
-    this._timers.forEach(clearTimeout);
-  }
-  /**
-   * Determines which items are viewable based on the current metrics and config.
-   */
-  computeViewableItems(props, scrollOffset, viewportHeight, getFrameMetrics, renderRange) {
-    const itemCount = props.getItemCount(props.data);
-    const {
-      itemVisiblePercentThreshold,
-      viewAreaCoveragePercentThreshold
-    } = this._config;
-    const viewAreaMode = viewAreaCoveragePercentThreshold != null;
-    const viewablePercentThreshold = viewAreaMode ? viewAreaCoveragePercentThreshold : itemVisiblePercentThreshold;
-    (0, import_react_native_web_internals.invariant)(viewablePercentThreshold != null && itemVisiblePercentThreshold != null !== (viewAreaCoveragePercentThreshold != null), "Must set exactly one of itemVisiblePercentThreshold or viewAreaCoveragePercentThreshold");
-    const viewableIndices = [];
-    if (itemCount === 0) {
-      return viewableIndices;
-    }
-    let firstVisible = -1;
-    const {
-      first,
-      last
-    } = renderRange || {
-      first: 0,
-      last: itemCount - 1
-    };
-    if (last >= itemCount) {
-      console.warn("Invalid render range computing viewability " + JSON.stringify({
-        renderRange,
-        itemCount
-      }));
-      return [];
-    }
-    for (let idx = first; idx <= last; idx++) {
-      const metrics = getFrameMetrics(idx, props);
-      if (!metrics) {
-        continue;
-      }
-      const top = metrics.offset - scrollOffset;
-      const bottom = top + metrics.length;
-      if (top < viewportHeight && bottom > 0) {
-        firstVisible = idx;
-        if (_isViewable(viewAreaMode, viewablePercentThreshold, top, bottom, viewportHeight, metrics.length)) {
-          viewableIndices.push(idx);
-        }
-      } else if (firstVisible >= 0) {
-        break;
-      }
-    }
-    return viewableIndices;
-  }
-  /**
-   * Figures out which items are viewable and how that has changed from before and calls
-   * `onViewableItemsChanged` as appropriate.
-   */
-  onUpdate(props, scrollOffset, viewportHeight, getFrameMetrics, createViewToken, onViewableItemsChanged, renderRange) {
-    const itemCount = props.getItemCount(props.data);
-    if (this._config.waitForInteraction && !this._hasInteracted || itemCount === 0 || !getFrameMetrics(0, props)) {
-      return;
-    }
-    let viewableIndices = [];
-    if (itemCount) {
-      viewableIndices = this.computeViewableItems(props, scrollOffset, viewportHeight, getFrameMetrics, renderRange);
-    }
-    if (this._viewableIndices.length === viewableIndices.length && this._viewableIndices.every((v, ii) => v === viewableIndices[ii])) {
-      return;
-    }
-    this._viewableIndices = viewableIndices;
-    if (this._config.minimumViewTime) {
-      const handle = setTimeout(() => {
-        this._timers.delete(handle);
-        this._onUpdateSync(props, viewableIndices, onViewableItemsChanged, createViewToken);
-      }, this._config.minimumViewTime);
-      this._timers.add(handle);
-    } else {
-      this._onUpdateSync(props, viewableIndices, onViewableItemsChanged, createViewToken);
-    }
-  }
-  resetViewableIndices() {
-    this._viewableIndices = [];
-  }
-  recordInteraction() {
-    this._hasInteracted = true;
-  }
-  _onUpdateSync(props, viewableIndicesToCheck, onViewableItemsChanged, createViewToken) {
-    viewableIndicesToCheck = viewableIndicesToCheck.filter(ii => this._viewableIndices.includes(ii));
-    const prevItems = this._viewableItems;
-    const nextItems = new Map(viewableIndicesToCheck.map(ii => {
-      const viewable = createViewToken(ii, true, props);
-      return [viewable.key, viewable];
-    }));
-    const changed = [];
-    for (const [key, viewable] of nextItems) {
-      if (!prevItems.has(key)) {
-        changed.push(viewable);
-      }
-    }
-    for (const [key, viewable] of prevItems) {
-      if (!nextItems.has(key)) {
-        changed.push({
-          ...viewable,
-          isViewable: false
-        });
-      }
-    }
-    if (changed.length > 0) {
-      this._viewableItems = nextItems;
-      onViewableItemsChanged({
-        viewableItems: Array.from(nextItems.values()),
-        changed
-      });
-    }
-  }
-}
+var ViewabilityHelper = class {
+	_config;
+	_hasInteracted = false;
+	_timers = /* @__PURE__ */ new Set();
+	_viewableIndices = [];
+	_viewableItems = /* @__PURE__ */ new Map();
+	constructor(config = { viewAreaCoveragePercentThreshold: 0 }) {
+		this._config = config;
+	}
+	/**
+	* Cleanup, e.g. on unmount. Clears any pending timers.
+	*/
+	dispose() {
+		this._timers.forEach(clearTimeout);
+	}
+	/**
+	* Determines which items are viewable based on the current metrics and config.
+	*/
+	computeViewableItems(props, scrollOffset, viewportHeight, getFrameMetrics, renderRange) {
+		const itemCount = props.getItemCount(props.data);
+		const { itemVisiblePercentThreshold, viewAreaCoveragePercentThreshold } = this._config;
+		const viewAreaMode = viewAreaCoveragePercentThreshold != null;
+		const viewablePercentThreshold = viewAreaMode ? viewAreaCoveragePercentThreshold : itemVisiblePercentThreshold;
+		(0, import_react_native_web_internals.invariant)(viewablePercentThreshold != null && itemVisiblePercentThreshold != null !== (viewAreaCoveragePercentThreshold != null), "Must set exactly one of itemVisiblePercentThreshold or viewAreaCoveragePercentThreshold");
+		const viewableIndices = [];
+		if (itemCount === 0) {
+			return viewableIndices;
+		}
+		let firstVisible = -1;
+		const { first, last } = renderRange || {
+			first: 0,
+			last: itemCount - 1
+		};
+		if (last >= itemCount) {
+			console.warn("Invalid render range computing viewability " + JSON.stringify({
+				renderRange,
+				itemCount
+			}));
+			return [];
+		}
+		for (let idx = first; idx <= last; idx++) {
+			const metrics = getFrameMetrics(idx, props);
+			if (!metrics) {
+				continue;
+			}
+			const top = metrics.offset - scrollOffset;
+			const bottom = top + metrics.length;
+			if (top < viewportHeight && bottom > 0) {
+				firstVisible = idx;
+				if (_isViewable(viewAreaMode, viewablePercentThreshold, top, bottom, viewportHeight, metrics.length)) {
+					viewableIndices.push(idx);
+				}
+			} else if (firstVisible >= 0) {
+				break;
+			}
+		}
+		return viewableIndices;
+	}
+	/**
+	* Figures out which items are viewable and how that has changed from before and calls
+	* `onViewableItemsChanged` as appropriate.
+	*/
+	onUpdate(props, scrollOffset, viewportHeight, getFrameMetrics, createViewToken, onViewableItemsChanged, renderRange) {
+		const itemCount = props.getItemCount(props.data);
+		if (this._config.waitForInteraction && !this._hasInteracted || itemCount === 0 || !getFrameMetrics(0, props)) {
+			return;
+		}
+		let viewableIndices = [];
+		if (itemCount) {
+			viewableIndices = this.computeViewableItems(props, scrollOffset, viewportHeight, getFrameMetrics, renderRange);
+		}
+		if (this._viewableIndices.length === viewableIndices.length && this._viewableIndices.every((v, ii) => v === viewableIndices[ii])) {
+			return;
+		}
+		this._viewableIndices = viewableIndices;
+		if (this._config.minimumViewTime) {
+			const handle = setTimeout(() => {
+				this._timers.delete(handle);
+				this._onUpdateSync(props, viewableIndices, onViewableItemsChanged, createViewToken);
+			}, this._config.minimumViewTime);
+			this._timers.add(handle);
+		} else {
+			this._onUpdateSync(props, viewableIndices, onViewableItemsChanged, createViewToken);
+		}
+	}
+	resetViewableIndices() {
+		this._viewableIndices = [];
+	}
+	recordInteraction() {
+		this._hasInteracted = true;
+	}
+	_onUpdateSync(props, viewableIndicesToCheck, onViewableItemsChanged, createViewToken) {
+		viewableIndicesToCheck = viewableIndicesToCheck.filter((ii) => this._viewableIndices.includes(ii));
+		const prevItems = this._viewableItems;
+		const nextItems = new Map(viewableIndicesToCheck.map((ii) => {
+			const viewable = createViewToken(ii, true, props);
+			return [viewable.key, viewable];
+		}));
+		const changed = [];
+		for (const [key, viewable] of nextItems) {
+			if (!prevItems.has(key)) {
+				changed.push(viewable);
+			}
+		}
+		for (const [key, viewable] of prevItems) {
+			if (!nextItems.has(key)) {
+				changed.push({
+					...viewable,
+					isViewable: false
+				});
+			}
+		}
+		if (changed.length > 0) {
+			this._viewableItems = nextItems;
+			onViewableItemsChanged({
+				viewableItems: Array.from(nextItems.values()),
+				changed
+			});
+		}
+	}
+};
 function _isViewable(viewAreaMode, viewablePercentThreshold, top, bottom, viewportHeight, itemLength) {
-  if (_isEntirelyVisible(top, bottom, viewportHeight)) {
-    return true;
-  } else {
-    const pixels = _getPixelsVisible(top, bottom, viewportHeight);
-    const percent = 100 * (viewAreaMode ? pixels / viewportHeight : pixels / itemLength);
-    return percent >= viewablePercentThreshold;
-  }
+	if (_isEntirelyVisible(top, bottom, viewportHeight)) {
+		return true;
+	} else {
+		const pixels = _getPixelsVisible(top, bottom, viewportHeight);
+		const percent = 100 * (viewAreaMode ? pixels / viewportHeight : pixels / itemLength);
+		return percent >= viewablePercentThreshold;
+	}
 }
 function _getPixelsVisible(top, bottom, viewportHeight) {
-  const visibleHeight = Math.min(bottom, viewportHeight) - Math.max(top, 0);
-  return Math.max(0, visibleHeight);
+	const visibleHeight = Math.min(bottom, viewportHeight) - Math.max(top, 0);
+	return Math.max(0, visibleHeight);
 }
 function _isEntirelyVisible(top, bottom, viewportHeight) {
-  return top >= 0 && bottom <= viewportHeight && bottom > top;
+	return top >= 0 && bottom <= viewportHeight && bottom > top;
 }
-var ViewabilityHelper_default = ViewabilityHelper;
+var ViewabilityHelper_default = ViewabilityHelper;

package/dist/cjs/vendor/react-native/VirtualizeUtils/index.cjs

@@ -3,142 +3,140 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
-  for (var name in all) __defProp(target, name, {
-    get: all[name],
-    enumerable: true
-  });
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
 };
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    });
-  }
-  return to;
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: () => from[key],
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
 };
-var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
-  value: true
-}), mod);
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var VirtualizeUtils_exports = {};
 __export(VirtualizeUtils_exports, {
-  computeWindowedRenderLimits: () => computeWindowedRenderLimits,
-  elementsThatOverlapOffsets: () => elementsThatOverlapOffsets,
-  keyExtractor: () => keyExtractor,
-  newRangeCount: () => newRangeCount
+	computeWindowedRenderLimits: () => computeWindowedRenderLimits,
+	elementsThatOverlapOffsets: () => elementsThatOverlapOffsets,
+	keyExtractor: () => keyExtractor,
+	newRangeCount: () => newRangeCount
 });
 module.exports = __toCommonJS(VirtualizeUtils_exports);
 function elementsThatOverlapOffsets(offsets, props, getFrameMetrics, zoomScale = 1) {
-  const itemCount = props.getItemCount(props.data);
-  const result = [];
-  for (let offsetIndex = 0; offsetIndex < offsets.length; offsetIndex++) {
-    const currentOffset = offsets[offsetIndex];
-    let left = 0;
-    let right = itemCount - 1;
-    while (left <= right) {
-      const mid = left + (right - left >>> 1);
-      const frame = getFrameMetrics(mid, props);
-      const scaledOffsetStart = frame.offset * zoomScale;
-      const scaledOffsetEnd = (frame.offset + frame.length) * zoomScale;
-      if (mid === 0 && currentOffset < scaledOffsetStart || mid !== 0 && currentOffset <= scaledOffsetStart) {
-        right = mid - 1;
-      } else if (currentOffset > scaledOffsetEnd) {
-        left = mid + 1;
-      } else {
-        result[offsetIndex] = mid;
-        break;
-      }
-    }
-  }
-  return result;
+	const itemCount = props.getItemCount(props.data);
+	const result = [];
+	for (let offsetIndex = 0; offsetIndex < offsets.length; offsetIndex++) {
+		const currentOffset = offsets[offsetIndex];
+		let left = 0;
+		let right = itemCount - 1;
+		while (left <= right) {
+			const mid = left + (right - left >>> 1);
+			const frame = getFrameMetrics(mid, props);
+			const scaledOffsetStart = frame.offset * zoomScale;
+			const scaledOffsetEnd = (frame.offset + frame.length) * zoomScale;
+			if (mid === 0 && currentOffset < scaledOffsetStart || mid !== 0 && currentOffset <= scaledOffsetStart) {
+				right = mid - 1;
+			} else if (currentOffset > scaledOffsetEnd) {
+				left = mid + 1;
+			} else {
+				result[offsetIndex] = mid;
+				break;
+			}
+		}
+	}
+	return result;
 }
 function newRangeCount(prev, next) {
-  return next.last - next.first + 1 - Math.max(0, 1 + Math.min(next.last, prev.last) - Math.max(next.first, prev.first));
+	return next.last - next.first + 1 - Math.max(0, 1 + Math.min(next.last, prev.last) - Math.max(next.first, prev.first));
 }
 function computeWindowedRenderLimits(props, maxToRenderPerBatch, windowSize, prev, getFrameMetricsApprox, scrollMetrics) {
-  const itemCount = props.getItemCount(props.data);
-  if (itemCount === 0) {
-    return {
-      first: 0,
-      last: -1
-    };
-  }
-  const {
-    offset,
-    velocity,
-    visibleLength,
-    zoomScale = 1
-  } = scrollMetrics;
-  const visibleBegin = Math.max(0, offset);
-  const visibleEnd = visibleBegin + visibleLength;
-  const overscanLength = (windowSize - 1) * visibleLength;
-  const leadFactor = 0.5;
-  const fillPreference = velocity > 1 ? "after" : velocity < -1 ? "before" : "none";
-  const overscanBegin = Math.max(0, visibleBegin - (1 - leadFactor) * overscanLength);
-  const overscanEnd = Math.max(0, visibleEnd + leadFactor * overscanLength);
-  const lastItemOffset = getFrameMetricsApprox(itemCount - 1, props).offset * zoomScale;
-  if (lastItemOffset < overscanBegin) {
-    return {
-      first: Math.max(0, itemCount - 1 - maxToRenderPerBatch),
-      last: itemCount - 1
-    };
-  }
-  let [overscanFirst, first, last, overscanLast] = elementsThatOverlapOffsets([overscanBegin, visibleBegin, visibleEnd, overscanEnd], props, getFrameMetricsApprox, zoomScale);
-  overscanFirst = overscanFirst == null ? 0 : overscanFirst;
-  first = first == null ? Math.max(0, overscanFirst) : first;
-  overscanLast = overscanLast == null ? itemCount - 1 : overscanLast;
-  last = last == null ? Math.min(overscanLast, first + maxToRenderPerBatch - 1) : last;
-  const visible = {
-    first,
-    last
-  };
-  let newCellCount = newRangeCount(prev, visible);
-  while (true) {
-    if (first <= overscanFirst && last >= overscanLast) {
-      break;
-    }
-    const maxNewCells = newCellCount >= maxToRenderPerBatch;
-    const firstWillAddMore = first <= prev.first || first > prev.last;
-    const firstShouldIncrement = first > overscanFirst && (!maxNewCells || !firstWillAddMore);
-    const lastWillAddMore = last >= prev.last || last < prev.first;
-    const lastShouldIncrement = last < overscanLast && (!maxNewCells || !lastWillAddMore);
-    if (maxNewCells && !firstShouldIncrement && !lastShouldIncrement) {
-      break;
-    }
-    if (firstShouldIncrement && !(fillPreference === "after" && lastShouldIncrement && lastWillAddMore)) {
-      if (firstWillAddMore) {
-        newCellCount++;
-      }
-      first--;
-    }
-    if (lastShouldIncrement && !(fillPreference === "before" && firstShouldIncrement && firstWillAddMore)) {
-      if (lastWillAddMore) {
-        newCellCount++;
-      }
-      last++;
-    }
-  }
-  if (!(last >= first && first >= 0 && last < itemCount && first >= overscanFirst && last <= overscanLast && first <= visible.first && last >= visible.last)) {
-    throw new Error("Bad window calculation " + JSON.stringify({
-      first,
-      last,
-      itemCount,
-      overscanFirst,
-      overscanLast,
-      visible
-    }));
-  }
-  return {
-    first,
-    last
-  };
+	const itemCount = props.getItemCount(props.data);
+	if (itemCount === 0) {
+		return {
+			first: 0,
+			last: -1
+		};
+	}
+	const { offset, velocity, visibleLength, zoomScale = 1 } = scrollMetrics;
+	const visibleBegin = Math.max(0, offset);
+	const visibleEnd = visibleBegin + visibleLength;
+	const overscanLength = (windowSize - 1) * visibleLength;
+	const leadFactor = .5;
+	const fillPreference = velocity > 1 ? "after" : velocity < -1 ? "before" : "none";
+	const overscanBegin = Math.max(0, visibleBegin - (1 - leadFactor) * overscanLength);
+	const overscanEnd = Math.max(0, visibleEnd + leadFactor * overscanLength);
+	const lastItemOffset = getFrameMetricsApprox(itemCount - 1, props).offset * zoomScale;
+	if (lastItemOffset < overscanBegin) {
+		return {
+			first: Math.max(0, itemCount - 1 - maxToRenderPerBatch),
+			last: itemCount - 1
+		};
+	}
+	let [overscanFirst, first, last, overscanLast] = elementsThatOverlapOffsets([
+		overscanBegin,
+		visibleBegin,
+		visibleEnd,
+		overscanEnd
+	], props, getFrameMetricsApprox, zoomScale);
+	overscanFirst = overscanFirst == null ? 0 : overscanFirst;
+	first = first == null ? Math.max(0, overscanFirst) : first;
+	overscanLast = overscanLast == null ? itemCount - 1 : overscanLast;
+	last = last == null ? Math.min(overscanLast, first + maxToRenderPerBatch - 1) : last;
+	const visible = {
+		first,
+		last
+	};
+	let newCellCount = newRangeCount(prev, visible);
+	while (true) {
+		if (first <= overscanFirst && last >= overscanLast) {
+			break;
+		}
+		const maxNewCells = newCellCount >= maxToRenderPerBatch;
+		const firstWillAddMore = first <= prev.first || first > prev.last;
+		const firstShouldIncrement = first > overscanFirst && (!maxNewCells || !firstWillAddMore);
+		const lastWillAddMore = last >= prev.last || last < prev.first;
+		const lastShouldIncrement = last < overscanLast && (!maxNewCells || !lastWillAddMore);
+		if (maxNewCells && !firstShouldIncrement && !lastShouldIncrement) {
+			break;
+		}
+		if (firstShouldIncrement && !(fillPreference === "after" && lastShouldIncrement && lastWillAddMore)) {
+			if (firstWillAddMore) {
+				newCellCount++;
+			}
+			first--;
+		}
+		if (lastShouldIncrement && !(fillPreference === "before" && firstShouldIncrement && firstWillAddMore)) {
+			if (lastWillAddMore) {
+				newCellCount++;
+			}
+			last++;
+		}
+	}
+	if (!(last >= first && first >= 0 && last < itemCount && first >= overscanFirst && last <= overscanLast && first <= visible.first && last >= visible.last)) {
+		throw new Error("Bad window calculation " + JSON.stringify({
+			first,
+			last,
+			itemCount,
+			overscanFirst,
+			overscanLast,
+			visible
+		}));
+	}
+	return {
+		first,
+		last
+	};
 }
 function keyExtractor(item, index) {
-  if (typeof item === "object" && item?.key != null) {
-    return item.key;
-  }
-  if (typeof item === "object" && item?.id != null) {
-    return item.id;
-  }
-  return String(index);
-}
+	if (typeof item === "object" && item?.key != null) {
+		return item.key;
+	}
+	if (typeof item === "object" && item?.id != null) {
+		return item.id;
+	}
+	return String(index);
+}