@hanzogui/react-native-web-lite 2.0.0-rc.41-hanzoai.5

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

@@ -0,0 +1,310 @@
+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: 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;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var VirtualizedList_exports = {};
+__export(VirtualizedList_exports, {
+  VirtualizedList: () => VirtualizedList,
+  default: () => VirtualizedList_default
+});
+module.exports = __toCommonJS(VirtualizedList_exports);
+var import_react_native_web_internals = require("@hanzogui/react-native-web-internals");
+var import_ScrollView = require("../../../ScrollView/index.cjs");
+var import_RefreshControl = require("../../../RefreshControl/index.cjs");
+var import_Batchinator = require("../Batchinator/index.cjs");
+var import_ChildListCollection = require("./ChildListCollection.cjs");
+var import_FillRateHelper = require("../FillRateHelper/index.cjs");
+var import_StateSafePureComponent = require("./StateSafePureComponent.cjs");
+var import_ViewabilityHelper = require("../ViewabilityHelper/index.cjs");
+var import_VirtualizedListCellRenderer = require("./VirtualizedListCellRenderer.cjs");
+var import_VirtualizedListContext = require("./VirtualizedListContext.cjs");
+var import_jsx_runtime = require("react/jsx-runtime");
+const __DEV__ = process.env.NODE_ENV !== "production";
+function horizontalOrDefault(horizontal) {
+  return horizontal ?? false;
+}
+function scrollEventThrottleOrDefault(scrollEventThrottle) {
+  return scrollEventThrottle ?? 50;
+}
+class VirtualizedList extends import_StateSafePureComponent.StateSafePureComponent {
+  static contextType = import_VirtualizedListContext.VirtualizedListContext;
+  constructor(props) {
+    super(props);
+    this._nestedChildLists = new import_ChildListCollection.ChildListCollection();
+    this._viewabilityTuples = [];
+    this._scrollMetrics = {
+      contentLength: 0,
+      dOffset: 0,
+      dt: 10,
+      offset: 0,
+      timestamp: 0,
+      velocity: 0,
+      visibleLength: 0
+    };
+    this._highestMeasuredFrameIndex = 0;
+    this._headerLength = 0;
+    this._footerLength = 0;
+    this._averageCellLength = 0;
+    this._hasWarned = {};
+    this._fillRateHelper = new import_FillRateHelper.FillRateHelper(this._getFrameMetrics);
+    this._updateCellsToRenderBatcher = new import_Batchinator.Batchinator(this._updateCellsToRender, this.props.updateCellsBatchingPeriod ?? 50);
+    if (this.props.viewabilityConfig && this.props.onViewableItemsChanged) {
+      this._viewabilityTuples.push({
+        viewabilityHelper: new import_ViewabilityHelper.ViewabilityHelper(this.props.viewabilityConfig),
+        onViewableItemsChanged: this.props.onViewableItemsChanged
+      });
+    }
+  }
+  scrollToEnd(params) {
+    const animated = params ? params.animated : true;
+    const veryLast = this.props.getItemCount(this.props.data) - 1;
+    if (veryLast < 0) {
+      return;
+    }
+    const frame = this.__getFrameMetricsApprox(veryLast, this.props);
+    const offset = Math.max(0, frame.offset + frame.length + this._footerLength - this._scrollMetrics.visibleLength);
+    if (this._scrollRef == null) {
+      return;
+    }
+    if (this._scrollRef.scrollTo == null) {
+      console.warn("No scrollTo method provided. This may be because you have two nested VirtualizedLists with the same orientation, or because you are using a custom component that does not implement scrollTo.");
+      return;
+    }
+    this._scrollRef.scrollTo(horizontalOrDefault(this.props.horizontal) ? {
+      x: offset,
+      animated
+    } : {
+      y: offset,
+      animated
+    });
+  }
+  scrollToIndex(params) {
+    const {
+      data,
+      horizontal,
+      getItemCount,
+      getItemLayout,
+      onScrollToIndexFailed
+    } = this.props;
+    const {
+      animated,
+      index,
+      viewOffset,
+      viewPosition
+    } = params;
+    (0, import_react_native_web_internals.invariant)(index >= 0, `scrollToIndex out of range: requested index ${index} but minimum is 0`);
+    (0, import_react_native_web_internals.invariant)(getItemCount(data) >= 1, `scrollToIndex out of range: item length ${getItemCount(data)} but minimum is 1`);
+    (0, import_react_native_web_internals.invariant)(index < getItemCount(data), `scrollToIndex out of range: requested index ${index} is out of 0 to ${getItemCount(data) - 1}`);
+    if (!getItemLayout && index > this._highestMeasuredFrameIndex) {
+      (0, import_react_native_web_internals.invariant)(!!onScrollToIndexFailed, "scrollToIndex should be used in conjunction with getItemLayout or onScrollToIndexFailed, otherwise there is no way to know the location of offscreen indices or handle failures.");
+      onScrollToIndexFailed({
+        averageItemLength: this._averageCellLength,
+        highestMeasuredFrameIndex: this._highestMeasuredFrameIndex,
+        index
+      });
+      return;
+    }
+    const frame = this.__getFrameMetricsApprox(Math.floor(index), this.props);
+    const offset = Math.max(0, this._getOffsetApprox(index, this.props) - (viewPosition || 0) * (this._scrollMetrics.visibleLength - frame.length)) - (viewOffset || 0);
+    if (this._scrollRef == null) {
+      return;
+    }
+    this._scrollRef.scrollTo(horizontalOrDefault(horizontal) ? {
+      x: offset,
+      animated
+    } : {
+      y: offset,
+      animated
+    });
+  }
+  scrollToItem(params) {
+    const {
+      data,
+      getItem,
+      getItemCount,
+      horizontal,
+      onScrollToIndexFailed
+    } = this.props;
+    const {
+      animated,
+      item,
+      viewPosition,
+      viewOffset
+    } = params;
+    const index = this.props.data.indexOf(item);
+    if (index !== -1) {
+      this.scrollToIndex({
+        animated,
+        index,
+        viewOffset,
+        viewPosition
+      });
+    } else {
+      const itemCount = getItemCount(data);
+      for (let i = 0; i < itemCount; i++) {
+        if (getItem(data, i) === item) {
+          this.scrollToIndex({
+            animated,
+            index: i,
+            viewOffset,
+            viewPosition
+          });
+          break;
+        }
+      }
+    }
+  }
+  scrollToOffset(params) {
+    const {
+      animated,
+      offset
+    } = params;
+    if (this._scrollRef == null) {
+      return;
+    }
+    this._scrollRef.scrollTo(horizontalOrDefault(this.props.horizontal) ? {
+      x: offset,
+      animated
+    } : {
+      y: offset,
+      animated
+    });
+  }
+  recordInteraction() {
+    this._nestedChildLists.forEach(childList => {
+      childList.recordInteraction();
+    });
+    this._viewabilityTuples.forEach(viewabilityTuple => {
+      viewabilityTuple.viewabilityHelper.recordInteraction();
+    });
+  }
+  flashScrollIndicators() {
+    if (this._scrollRef && this._scrollRef.flashScrollIndicators) {
+      this._scrollRef.flashScrollIndicators();
+    }
+  }
+  getScrollResponder() {
+    if (this._scrollRef && this._scrollRef.getScrollResponder) {
+      return this._scrollRef.getScrollResponder();
+    }
+  }
+  getScrollableNode() {
+    if (this._scrollRef && this._scrollRef.getScrollableNode) {
+      return this._scrollRef.getScrollableNode();
+    }
+  }
+  getScrollRef() {
+    return this._scrollRef;
+  }
+  setNativeProps(props) {
+    if (this._scrollRef) {
+      this._scrollRef.setNativeProps(props);
+    }
+  }
+  render() {
+    const {
+      ListEmptyComponent,
+      ListFooterComponent,
+      ListHeaderComponent,
+      data,
+      debug,
+      disableVirtualization,
+      getItem,
+      getItemCount,
+      getItemLayout,
+      horizontal,
+      keyExtractor,
+      numColumns,
+      onEndReached,
+      onEndReachedThreshold,
+      onLayout,
+      onRefresh,
+      onScroll,
+      onScrollBeginDrag,
+      onScrollEndDrag,
+      onMomentumScrollBegin,
+      onMomentumScrollEnd,
+      onStartReached,
+      onStartReachedThreshold,
+      onViewableItemsChanged,
+      refreshing,
+      removeClippedSubviews,
+      renderItem,
+      viewabilityConfig,
+      viewabilityConfigCallbackPairs,
+      ...restProps
+    } = this.props;
+    const itemCount = getItemCount(data);
+    if (itemCount === 0) {
+      return ListEmptyComponent ? /* @__PURE__ */(0, import_jsx_runtime.jsx)(ListEmptyComponent, {}) : null;
+    }
+    return /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_ScrollView.ScrollView, {
+      ...restProps,
+      ref: this._captureRef,
+      onContentSizeChange: this._onContentSizeChange,
+      onLayout: this._onLayout,
+      onScroll: this._onScroll,
+      refreshControl: onRefresh && /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_RefreshControl.RefreshControl, {
+        refreshing,
+        onRefresh
+      }),
+      scrollEventThrottle: scrollEventThrottleOrDefault(this.props.scrollEventThrottle),
+      removeClippedSubviews,
+      children: this._renderChildren()
+    });
+  }
+  _renderChildren() {
+    const {
+      data,
+      getItem,
+      getItemCount,
+      renderItem
+    } = this.props;
+    const items = [];
+    for (let i = 0; i < getItemCount(data); i++) {
+      const item = getItem(data, i);
+      items.push(/* @__PURE__ */(0, import_jsx_runtime.jsx)(import_VirtualizedListCellRenderer.CellRenderer, {
+        cellKey: String(i),
+        index: i,
+        item,
+        renderItem
+      }, this.props.keyExtractor ? this.props.keyExtractor(item, i) : i));
+    }
+    return items;
+  }
+  _captureRef = ref => {
+    this._scrollRef = ref;
+  };
+  _onContentSizeChange = (width, height) => {};
+  _onLayout = event => {};
+  _onScroll = event => {};
+  __getFrameMetricsApprox(index, props) {
+    const frame = {
+      length: this._averageCellLength,
+      offset: this._averageCellLength * index
+    };
+    return frame;
+  }
+  _getOffsetApprox(index, props) {
+    return this.__getFrameMetricsApprox(index, props).offset;
+  }
+}
+var VirtualizedList_default = VirtualizedList;

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

@@ -0,0 +1,165 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  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;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+// If the importer is in node compatibility mode or this is not an ESM
+// file that has been converted to a CommonJS file using a Babel-
+// compatible transform (i.e. "__esModule" has not been set), then set
+// "default" to the CommonJS "module.exports" for node compatibility.
+isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var VirtualizedSectionList_exports = {};
+__export(VirtualizedSectionList_exports, {
+  VirtualizedSectionList: () => VirtualizedSectionList,
+  default: () => VirtualizedSectionList_default
+});
+module.exports = __toCommonJS(VirtualizedSectionList_exports);
+var import_VirtualizedList = require("../VirtualizedList/index.cjs");
+var React = __toESM(require("react"), 1);
+var import_jsx_runtime = require("react/jsx-runtime");
+const defaultProps = {
+  data: [],
+  key: null,
+  renderItem: null,
+  ItemSeparatorComponent: null,
+  keyExtractor: null
+};
+class VirtualizedSectionList extends React.PureComponent {
+  scrollToLocation(params) {
+    let index = params.itemIndex;
+    for (let i = 0; i < params.sectionIndex; i++) {
+      index += this.props.getItemCount(this.props.sections[i].data) + 2;
+    }
+    let viewOffset = params.viewOffset || 0;
+    if (this._listRef == null) {
+      return;
+    }
+    if (params.itemIndex > 0 && this.props.stickySectionHeadersEnabled) {
+      const frame = this._listRef.__getFrameMetricsApprox(index - params.itemIndex, this._listRef.props);
+      viewOffset += frame.length;
+    }
+    const toIndexParams = {
+      ...params,
+      viewOffset,
+      index
+    };
+    this._listRef.scrollToIndex(toIndexParams);
+  }
+  getListRef() {
+    return this._listRef;
+  }
+  render() {
+    const {
+      ItemSeparatorComponent,
+      SectionSeparatorComponent,
+      renderItem: _renderItem,
+      renderSectionFooter,
+      renderSectionHeader,
+      sections: _sections,
+      stickySectionHeadersEnabled,
+      ...passThroughProps
+    } = this.props;
+    const listHeaderOffset = this.props.ListHeaderComponent ? 1 : 0;
+    const stickyHeaderIndices = this.props.stickySectionHeadersEnabled ? [] : void 0;
+    let itemCount = 0;
+    for (const section of this.props.sections) {
+      if (stickyHeaderIndices != null) {
+        stickyHeaderIndices.push(itemCount + listHeaderOffset);
+      }
+      itemCount += 2;
+      itemCount += this.props.getItemCount(section.data);
+    }
+    const renderItem = this._renderItem(itemCount);
+    return /* @__PURE__ */(0, import_jsx_runtime.jsx)(import_VirtualizedList.VirtualizedList, {
+      ...passThroughProps,
+      keyExtractor: this._keyExtractor,
+      stickyHeaderIndices,
+      renderItem,
+      data: this.props.sections,
+      getItem: (sections, index) => this._getItem(this.props, sections, index),
+      getItemCount: () => itemCount,
+      onViewableItemsChanged: this.props.onViewableItemsChanged ? this._onViewableItemsChanged : void 0,
+      ref: this._captureRef
+    });
+  }
+  _getItem(props, sections, index) {
+    if (!sections) {
+      return null;
+    }
+    let itemIdx = index - 1;
+    for (let i = 0; i < sections.length; i++) {
+      const section = sections[i];
+      const sectionData = section.data;
+      const itemCount = props.getItemCount(sectionData);
+      if (itemIdx === -1 || itemIdx === itemCount) {
+        return section;
+      } else if (itemIdx < itemCount) {
+        return props.getItem(sectionData, itemIdx);
+      } else {
+        itemIdx -= itemCount + 2;
+      }
+    }
+    return null;
+  }
+  _keyExtractor = (item, index) => {
+    const keyExtractor = this.props.keyExtractor || this._defaultKeyExtractor;
+    return keyExtractor(item, index);
+  };
+  _defaultKeyExtractor = (item, index) => {
+    return item.key != null ? item.key : String(index);
+  };
+  _captureRef = ref => {
+    this._listRef = ref;
+  };
+  _renderItem = itemCount => {
+    return ({
+      item,
+      index
+    }) => {
+      if (index === 0 || index === itemCount - 1) {
+        return null;
+      }
+      const renderItem = this.props.renderItem || this._defaultRenderItem;
+      return renderItem({
+        item,
+        index,
+        section: item
+      });
+    };
+  };
+  _defaultRenderItem = ({
+    item
+  }) => {
+    return null;
+  };
+  _onViewableItemsChanged = info => {
+    if (this.props.onViewableItemsChanged) {
+      this.props.onViewableItemsChanged(info);
+    }
+  };
+}
+VirtualizedSectionList.defaultProps = defaultProps;
+var VirtualizedSectionList_default = VirtualizedSectionList;

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

@@ -0,0 +1,74 @@
+"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: 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;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var deepDiffer_exports = {};
+__export(deepDiffer_exports, {
+  deepDiffer: () => deepDiffer,
+  default: () => deepDiffer_default
+});
+module.exports = __toCommonJS(deepDiffer_exports);
+const deepDiffer = function (one, two, maxDepth = -1) {
+  if (maxDepth === 0) {
+    return true;
+  }
+  if (one === two) {
+    return false;
+  }
+  if (typeof one === "function" && typeof two === "function") {
+    return false;
+  }
+  if (typeof one !== "object" || one === null) {
+    return one !== two;
+  }
+  if (typeof two !== "object" || two === null) {
+    return true;
+  }
+  if (one.constructor !== two.constructor) {
+    return true;
+  }
+  if (Array.isArray(one)) {
+    const len = one.length;
+    if (two.length !== len) {
+      return true;
+    }
+    for (let ii = 0; ii < len; ii++) {
+      if (deepDiffer(one[ii], two[ii], maxDepth - 1)) {
+        return true;
+      }
+    }
+  } else {
+    for (const key in one) {
+      if (deepDiffer(one[key], two[key], maxDepth - 1)) {
+        return true;
+      }
+    }
+    for (const twoKey in two) {
+      if (one[twoKey] === void 0 && two[twoKey] !== void 0) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+var deepDiffer_default = deepDiffer;

package/dist/cjs/vendor/react-native/emitter/EventEmitter.cjs

@@ -0,0 +1,32 @@
+"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: 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;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var EventEmitter_exports = {};
+__export(EventEmitter_exports, {
+  EventEmitter: () => import_EventEmitter.EventEmitter,
+  default: () => EventEmitter_default
+});
+module.exports = __toCommonJS(EventEmitter_exports);
+var import_EventEmitter = require("./_EventEmitter.cjs");
+var EventEmitter_default = import_EventEmitter.EventEmitter;

package/dist/cjs/vendor/react-native/emitter/EventSubscription.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/vendor/react-native/emitter/_EmitterSubscription.cjs

@@ -0,0 +1,59 @@
+"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: 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;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var EmitterSubscription_exports = {};
+__export(EmitterSubscription_exports, {
+  EmitterSubscription: () => EmitterSubscription,
+  default: () => EmitterSubscription_default
+});
+module.exports = __toCommonJS(EmitterSubscription_exports);
+var import_EventSubscription = require("./_EventSubscription.cjs");
+class EmitterSubscription extends import_EventSubscription._EventSubscription {
+  /**
+   * @param {EventEmitter} emitter - The event emitter that registered this
+   *   subscription
+   * @param {EventSubscriptionVendor} subscriber - The subscriber that controls
+   *   this subscription
+   * @param {function} listener - Function to invoke when the specified event is
+   *   emitted
+   * @param {*} context - Optional context object to use when invoking the
+   *   listener
+   */
+  constructor(emitter, subscriber, listener, context) {
+    super(subscriber);
+    this.emitter = emitter;
+    this.listener = listener;
+    this.context = context;
+  }
+  /**
+   * Removes this subscription from the emitter that registered it.
+   * Note: we're overriding the `remove()` method of _EventSubscription here
+   * but deliberately not calling `super.remove()` as the responsibility
+   * for removing the subscription lies with the EventEmitter.
+   */
+  remove() {
+    this.emitter.removeSubscription(this);
+  }
+}
+var EmitterSubscription_default = EmitterSubscription;