@tamagui/react-native-web-lite 1.116.1 → 1.116.3

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

@@ -0,0 +1,133 @@
+var __defProp = Object.defineProperty;
+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: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__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: !0
+}), mod);
+var ViewabilityHelper_exports = {};
+__export(ViewabilityHelper_exports, {
+  default: () => ViewabilityHelper_default
+});
+module.exports = __toCommonJS(ViewabilityHelper_exports);
+var import_react_native_web_internals = require("@tamagui/react-native-web-internals");
+class ViewabilityHelper {
+  _config;
+  _hasInteracted = !1;
+  _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),
+      {
+        itemVisiblePercentThreshold,
+        viewAreaCoveragePercentThreshold
+      } = this._config,
+      viewAreaMode = viewAreaCoveragePercentThreshold != null,
+      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) return console.warn("Invalid render range computing viewability " + JSON.stringify({
+      renderRange,
+      itemCount
+    })), [];
+    for (let idx = first; idx <= last; idx++) {
+      const metrics = getFrameMetrics(idx, props);
+      if (!metrics) continue;
+      const top = metrics.offset - scrollOffset,
+        bottom = top + metrics.length;
+      if (top < viewportHeight && bottom > 0) firstVisible = idx, _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)), !(this._viewableIndices.length === viewableIndices.length && this._viewableIndices.every((v, ii) => v === viewableIndices[ii]))) if (this._viewableIndices = viewableIndices, 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 = !0;
+  }
+  _onUpdateSync(props, viewableIndicesToCheck, onViewableItemsChanged, createViewToken) {
+    viewableIndicesToCheck = viewableIndicesToCheck.filter(ii => this._viewableIndices.includes(ii));
+    const prevItems = this._viewableItems,
+      nextItems = new Map(viewableIndicesToCheck.map(ii => {
+        const viewable = createViewToken(ii, !0, props);
+        return [viewable.key, viewable];
+      })),
+      changed = [];
+    for (const [key, viewable] of nextItems) prevItems.has(key) || changed.push(viewable);
+    for (const [key, viewable] of prevItems) nextItems.has(key) || changed.push({
+      ...viewable,
+      isViewable: !1
+    });
+    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 !0;
+  {
+    const pixels = _getPixelsVisible(top, bottom, viewportHeight);
+    return 100 * (viewAreaMode ? pixels / viewportHeight : pixels / itemLength) >= viewablePercentThreshold;
+  }
+}
+function _getPixelsVisible(top, bottom, viewportHeight) {
+  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;
+}
+var ViewabilityHelper_default = ViewabilityHelper;

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

@@ -0,0 +1,144 @@
+var __defProp = Object.defineProperty;
+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: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }), mod);
+var ViewabilityHelper_exports = {};
+__export(ViewabilityHelper_exports, {
+  default: () => ViewabilityHelper_default
+});
+module.exports = __toCommonJS(ViewabilityHelper_exports);
+var import_react_native_web_internals = require("@tamagui/react-native-web-internals");
+class ViewabilityHelper {
+  _config;
+  _hasInteracted = !1;
+  _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), { itemVisiblePercentThreshold, viewAreaCoveragePercentThreshold } = this._config, viewAreaMode = viewAreaCoveragePercentThreshold != null, 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)
+      return console.warn(
+        "Invalid render range computing viewability " + JSON.stringify({ renderRange, itemCount })
+      ), [];
+    for (let idx = first; idx <= last; idx++) {
+      const metrics = getFrameMetrics(idx, props);
+      if (!metrics)
+        continue;
+      const top = metrics.offset - scrollOffset, bottom = top + metrics.length;
+      if (top < viewportHeight && bottom > 0)
+        firstVisible = idx, _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
+    )), !(this._viewableIndices.length === viewableIndices.length && this._viewableIndices.every((v, ii) => v === viewableIndices[ii])))
+      if (this._viewableIndices = viewableIndices, 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 = !0;
+  }
+  _onUpdateSync(props, viewableIndicesToCheck, onViewableItemsChanged, createViewToken) {
+    viewableIndicesToCheck = viewableIndicesToCheck.filter(
+      (ii) => this._viewableIndices.includes(ii)
+    );
+    const prevItems = this._viewableItems, nextItems = new Map(
+      viewableIndicesToCheck.map((ii) => {
+        const viewable = createViewToken(ii, !0, props);
+        return [viewable.key, viewable];
+      })
+    ), changed = [];
+    for (const [key, viewable] of nextItems)
+      prevItems.has(key) || changed.push(viewable);
+    for (const [key, viewable] of prevItems)
+      nextItems.has(key) || changed.push({ ...viewable, isViewable: !1 });
+    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 !0;
+  {
+    const pixels = _getPixelsVisible(top, bottom, viewportHeight);
+    return 100 * (viewAreaMode ? pixels / viewportHeight : pixels / itemLength) >= viewablePercentThreshold;
+  }
+}
+function _getPixelsVisible(top, bottom, viewportHeight) {
+  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;
+}
+var ViewabilityHelper_default = ViewabilityHelper;
+//# sourceMappingURL=ViewabilityHelper.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/vendor/react-native/ViewabilityHelper.ts"],
+  "mappings": "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",
+  "names": []
+}

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

@@ -0,0 +1,199 @@
+"use strict";
+var __defProp = Object.defineProperty;
+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: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__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: !0 }), mod);
+var ViewabilityHelper_exports = {};
+__export(ViewabilityHelper_exports, {
+  default: () => ViewabilityHelper_default
+});
+module.exports = __toCommonJS(ViewabilityHelper_exports);
+var import_react_native_web_internals = require("@tamagui/react-native-web-internals");
+function _class_call_check(instance, Constructor) {
+  if (!(instance instanceof Constructor))
+    throw new TypeError("Cannot call a class as a function");
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+  return protoProps && _defineProperties(Constructor.prototype, protoProps), staticProps && _defineProperties(Constructor, staticProps), Constructor;
+}
+function _define_property(obj, key, value) {
+  return key in obj ? Object.defineProperty(obj, key, {
+    value,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : obj[key] = value, obj;
+}
+var ViewabilityHelper = /* @__PURE__ */ function() {
+  "use strict";
+  function ViewabilityHelper2() {
+    var config = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
+      viewAreaCoveragePercentThreshold: 0
+    };
+    _class_call_check(this, ViewabilityHelper2), _define_property(this, "_config", void 0), _define_property(this, "_hasInteracted", !1), _define_property(this, "_timers", /* @__PURE__ */ new Set()), _define_property(this, "_viewableIndices", []), _define_property(this, "_viewableItems", /* @__PURE__ */ new Map()), this._config = config;
+  }
+  return _create_class(ViewabilityHelper2, [
+    {
+      /**
+      * Cleanup, e.g. on unmount. Clears any pending timers.
+      */
+      key: "dispose",
+      value: function() {
+        this._timers.forEach(clearTimeout);
+      }
+    },
+    {
+      /**
+      * Determines which items are viewable based on the current metrics and config.
+      */
+      key: "computeViewableItems",
+      value: function(props, scrollOffset, viewportHeight, getFrameMetrics, renderRange) {
+        var itemCount = props.getItemCount(props.data), { itemVisiblePercentThreshold, viewAreaCoveragePercentThreshold } = this._config, viewAreaMode = viewAreaCoveragePercentThreshold != null, 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");
+        var viewableIndices = [];
+        if (itemCount === 0)
+          return viewableIndices;
+        var firstVisible = -1, { first, last } = renderRange || {
+          first: 0,
+          last: itemCount - 1
+        };
+        if (last >= itemCount)
+          return console.warn("Invalid render range computing viewability " + JSON.stringify({
+            renderRange,
+            itemCount
+          })), [];
+        for (var idx = first; idx <= last; idx++) {
+          var metrics = getFrameMetrics(idx, props);
+          if (metrics) {
+            var top = metrics.offset - scrollOffset, bottom = top + metrics.length;
+            if (top < viewportHeight && bottom > 0)
+              firstVisible = idx, _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.
+      */
+      key: "onUpdate",
+      value: function(props, scrollOffset, viewportHeight, getFrameMetrics, createViewToken, onViewableItemsChanged, renderRange) {
+        var _this = this, itemCount = props.getItemCount(props.data);
+        if (!(this._config.waitForInteraction && !this._hasInteracted || itemCount === 0 || !getFrameMetrics(0, props))) {
+          var viewableIndices = [];
+          if (itemCount && (viewableIndices = this.computeViewableItems(props, scrollOffset, viewportHeight, getFrameMetrics, renderRange)), !(this._viewableIndices.length === viewableIndices.length && this._viewableIndices.every(function(v, ii) {
+            return v === viewableIndices[ii];
+          })))
+            if (this._viewableIndices = viewableIndices, this._config.minimumViewTime) {
+              var handle = setTimeout(function() {
+                _this._timers.delete(handle), _this._onUpdateSync(props, viewableIndices, onViewableItemsChanged, createViewToken);
+              }, this._config.minimumViewTime);
+              this._timers.add(handle);
+            } else
+              this._onUpdateSync(props, viewableIndices, onViewableItemsChanged, createViewToken);
+        }
+      }
+    },
+    {
+      key: "resetViewableIndices",
+      value: function() {
+        this._viewableIndices = [];
+      }
+    },
+    {
+      key: "recordInteraction",
+      value: function() {
+        this._hasInteracted = !0;
+      }
+    },
+    {
+      key: "_onUpdateSync",
+      value: function(props, viewableIndicesToCheck, onViewableItemsChanged, createViewToken) {
+        var _this = this;
+        viewableIndicesToCheck = viewableIndicesToCheck.filter(function(ii) {
+          return _this._viewableIndices.includes(ii);
+        });
+        var prevItems = this._viewableItems, nextItems = new Map(viewableIndicesToCheck.map(function(ii) {
+          var viewable2 = createViewToken(ii, !0, props);
+          return [
+            viewable2.key,
+            viewable2
+          ];
+        })), changed = [], _iteratorNormalCompletion = !0, _didIteratorError = !1, _iteratorError = void 0;
+        try {
+          for (var _iterator = nextItems[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
+            var [key, viewable] = _step.value;
+            prevItems.has(key) || changed.push(viewable);
+          }
+        } catch (err) {
+          _didIteratorError = !0, _iteratorError = err;
+        } finally {
+          try {
+            !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
+          } finally {
+            if (_didIteratorError)
+              throw _iteratorError;
+          }
+        }
+        var _iteratorNormalCompletion1 = !0, _didIteratorError1 = !1, _iteratorError1 = void 0;
+        try {
+          for (var _iterator1 = prevItems[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = !0) {
+            var [key1, viewable1] = _step1.value;
+            nextItems.has(key1) || changed.push({
+              ...viewable1,
+              isViewable: !1
+            });
+          }
+        } catch (err) {
+          _didIteratorError1 = !0, _iteratorError1 = err;
+        } finally {
+          try {
+            !_iteratorNormalCompletion1 && _iterator1.return != null && _iterator1.return();
+          } finally {
+            if (_didIteratorError1)
+              throw _iteratorError1;
+          }
+        }
+        changed.length > 0 && (this._viewableItems = nextItems, onViewableItemsChanged({
+          viewableItems: Array.from(nextItems.values()),
+          changed
+        }));
+      }
+    }
+  ]), ViewabilityHelper2;
+}();
+function _isViewable(viewAreaMode, viewablePercentThreshold, top, bottom, viewportHeight, itemLength) {
+  if (_isEntirelyVisible(top, bottom, viewportHeight))
+    return !0;
+  var pixels = _getPixelsVisible(top, bottom, viewportHeight), percent = 100 * (viewAreaMode ? pixels / viewportHeight : pixels / itemLength);
+  return percent >= viewablePercentThreshold;
+}
+function _getPixelsVisible(top, bottom, viewportHeight) {
+  var 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;
+}
+var ViewabilityHelper_default = ViewabilityHelper;
+//# sourceMappingURL=ViewabilityHelper.js.map

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

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/vendor/react-native/Users/n8/tamagui/code/packages/react-native-web-lite/src/vendor/react-native/ViewabilityHelper.ts"],
+  "mappings": "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",
+  "names": ["ViewabilityHelper", "config", "viewAreaCoveragePercentThreshold", "_config", "_hasInteracted", "_timers", "Set", "_viewableIndices", "_viewableItems", "Map", "dispose", "forEach", "clearTimeout", "computeViewableItems", "props", "scrollOffset", "viewportHeight", "getFrameMetrics", "renderRange", "itemCount", "getItemCount", "data", "itemVisiblePercentThreshold", "viewAreaMode", "viewablePercentThreshold", "invariant", "viewableIndices", "firstVisible", "first", "last", "console", "warn", "JSON", "stringify", "idx", "metrics", "top", "offset", "bottom", "length", "_isViewable", "push", "onUpdate", "createViewToken", "onViewableItemsChanged", "waitForInteraction", "every", "v", "ii", "minimumViewTime", "handle", "setTimeout", "delete", "_onUpdateSync", "add", "resetViewableIndices", "recordInteraction", "viewableIndicesToCheck", "filter", "includes", "prevItems", "nextItems", "map", "viewable", "key", "changed", "has", "isViewable", "viewableItems", "Array", "from", "values", "itemLength", "_isEntirelyVisible", "pixels", "_getPixelsVisible", "percent", "visibleHeight", "Math", "min", "max"]
+}

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

@@ -0,0 +1,106 @@
+var __defProp = Object.defineProperty;
+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: !0
+    });
+  },
+  __copyProps = (to, from, except, desc) => {
+    if (from && typeof from == "object" || typeof from == "function") for (let key of __getOwnPropNames(from)) !__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: !0
+}), mod);
+var VirtualizeUtils_exports = {};
+__export(VirtualizeUtils_exports, {
+  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),
+    result = [];
+  for (let offsetIndex = 0; offsetIndex < offsets.length; offsetIndex++) {
+    const currentOffset = offsets[offsetIndex];
+    let left = 0,
+      right = itemCount - 1;
+    for (; left <= right;) {
+      const mid = left + (right - left >>> 1),
+        frame = getFrameMetrics(mid, props),
+        scaledOffsetStart = frame.offset * zoomScale,
+        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));
+}
+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,
+    visibleBegin = Math.max(0, offset),
+    visibleEnd = visibleBegin + visibleLength,
+    overscanLength = (windowSize - 1) * visibleLength,
+    leadFactor = 0.5,
+    fillPreference = velocity > 1 ? "after" : velocity < -1 ? "before" : "none",
+    overscanBegin = Math.max(0, visibleBegin - (1 - leadFactor) * overscanLength),
+    overscanEnd = Math.max(0, visibleEnd + leadFactor * overscanLength);
+  if (getFrameMetricsApprox(itemCount - 1, props).offset * zoomScale < 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 ?? 0, first = first ?? Math.max(0, overscanFirst), overscanLast = overscanLast ?? itemCount - 1, last = last ?? Math.min(overscanLast, first + maxToRenderPerBatch - 1);
+  const visible = {
+    first,
+    last
+  };
+  let newCellCount = newRangeCount(prev, visible);
+  for (; !(first <= overscanFirst && last >= overscanLast);) {
+    const maxNewCells = newCellCount >= maxToRenderPerBatch,
+      firstWillAddMore = first <= prev.first || first > prev.last,
+      firstShouldIncrement = first > overscanFirst && (!maxNewCells || !firstWillAddMore),
+      lastWillAddMore = last >= prev.last || last < prev.first,
+      lastShouldIncrement = last < overscanLast && (!maxNewCells || !lastWillAddMore);
+    if (maxNewCells && !firstShouldIncrement && !lastShouldIncrement) break;
+    firstShouldIncrement && !(fillPreference === "after" && lastShouldIncrement && lastWillAddMore) && (firstWillAddMore && newCellCount++, first--), lastShouldIncrement && !(fillPreference === "before" && firstShouldIncrement && firstWillAddMore) && (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) {
+  return typeof item == "object" && item?.key != null ? item.key : typeof item == "object" && item?.id != null ? item.id : String(index);
+}