@hanwenbo/x-taro-ui 0.0.1

package/lib/components/flatList/flatList.js

@@ -0,0 +1,533 @@
+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);
+
+// src/components/flatList/flatList.tsx
+var flatList_exports = {};
+__export(flatList_exports, {
+  default: () => flatList_default
+});
+module.exports = __toCommonJS(flatList_exports);
+var import_react = __toESM(require("react"));
+var import_components = require("@tarojs/components");
+var import_taro = __toESM(require("@tarojs/taro"));
+var import_theme = require("../../theme");
+var import_utils = require("../../utils");
+var import_locale = require("../../utils/locale");
+var import_configProvider = require("../configProvider");
+var import_scrollView = require("../scrollView");
+var import_scrollTargetMeasurement = require("./scrollTargetMeasurement");
+function FlatListInner({
+  data,
+  dataSource,
+  renderItem,
+  keyExtractor,
+  horizontal = false,
+  numColumns = 1,
+  gap = 8,
+  divider = false,
+  dividerInset = 0,
+  loading = false,
+  loadingText,
+  emptyText,
+  header,
+  footer,
+  refreshing = false,
+  refreshText,
+  scrollHeight,
+  showScrollbar = true,
+  variant = "plain",
+  itemStyle,
+  getItemStyle,
+  onEndReached,
+  onEndReachedThreshold = 0.2,
+  ListEmptyComponent,
+  ListFooterComponent,
+  ListHeaderComponent,
+  onRefresh,
+  height,
+  contentContainerStyle,
+  itemHeight,
+  initialScrollOffset = 0,
+  onScroll,
+  children,
+  className,
+  style,
+  testID
+}, ref) {
+  var _a, _b;
+  const { theme } = (0, import_theme.useTheme)();
+  const config = (0, import_configProvider.useConfigProvider)();
+  const reactId = (0, import_react.useId)();
+  const instanceIdRef = (0, import_react.useRef)(`x-flat-list-${reactId.replace(/[^a-zA-Z0-9_-]/g, "")}`);
+  const scrollHostId = `${instanceIdRef.current}-scroll`;
+  const resolvedColumns = Math.max(1, Math.floor(numColumns) || 1);
+  const resolvedGap = toLength(gap);
+  const resolvedEndReachedThreshold = normalizeEndReachedThreshold(onEndReachedThreshold);
+  const hasDataProp = data !== void 0 || dataSource !== void 0;
+  const resolvedData = data ?? dataSource ?? [];
+  const childItems = import_react.default.Children.toArray(children).filter(hasRenderableNode);
+  const renderedItems = hasDataProp ? resolvedData.map((item, index) => ({
+    key: (keyExtractor == null ? void 0 : keyExtractor(item, index)) ?? String(index),
+    node: renderListItem(renderItem, item, index, theme.colors),
+    style: getItemStyle == null ? void 0 : getItemStyle(item, index)
+  })) : childItems.map((child, index) => ({ key: String(index), node: child, style: void 0 }));
+  const [scrollRequest, setScrollRequest] = (0, import_react.useState)({
+    offset: normalizeScrollOffset(initialScrollOffset),
+    animated: false,
+    sequence: 0,
+    target: null,
+    targetResolved: false
+  });
+  const scrollTargetId = resolveScrollTargetId(
+    instanceIdRef.current,
+    scrollRequest.target,
+    scrollRequest.sequence
+  );
+  const nearEndRef = (0, import_react.useRef)(false);
+  const measuredViewportRef = (0, import_react.useRef)({ width: 0, height: 0 });
+  const measuredExtentRef = (0, import_react.useRef)(0);
+  const [measuredExtent, setMeasuredExtent] = (0, import_react.useState)(0);
+  const resolvedLoadingText = loadingText !== void 0 ? loadingText : (0, import_locale.resolveLocaleText)(config.locale, "list.loading", "加载中...");
+  const resolvedEmptyText = emptyText !== void 0 ? emptyText : (0, import_locale.resolveLocaleText)(config.locale, "empty.text", "暂无数据");
+  const resolvedRefreshText = refreshText !== void 0 ? refreshText : (0, import_locale.resolveLocaleText)(config.locale, "pullToRefresh.refreshing", "刷新中...");
+  const requestScroll = (0, import_react.useCallback)((offset, animated) => {
+    setScrollRequest((current) => ({
+      offset: normalizeScrollOffset(offset),
+      animated,
+      sequence: current.sequence + 1,
+      target: null,
+      targetResolved: false
+    }));
+  }, []);
+  const requestTarget = (0, import_react.useCallback)((target, animated) => {
+    setScrollRequest((current) => ({
+      ...current,
+      animated,
+      sequence: current.sequence + 1,
+      target,
+      targetResolved: false
+    }));
+  }, []);
+  (0, import_react.useImperativeHandle)(
+    ref,
+    () => ({
+      scrollToIndex: ({ index, animated = true }) => {
+        const resolvedIndex = Math.floor(index);
+        if (!Number.isFinite(index) || resolvedIndex < 0 || resolvedIndex >= renderedItems.length) {
+          return;
+        }
+        requestTarget({ type: "item", index: resolvedIndex }, animated);
+      },
+      scrollToOffset: ({ offset, animated = true }) => requestScroll(offset, animated),
+      scrollToTop: (animated = true) => requestTarget({ type: "start" }, animated),
+      scrollToEnd: (animated = true) => requestTarget({ type: "end" }, animated),
+      scrollToStart: (animated = true) => requestTarget({ type: "start" }, animated),
+      getItemCount: () => renderedItems.length
+    }),
+    [renderedItems.length, requestScroll, requestTarget]
+  );
+  (0, import_react.useEffect)(() => {
+    requestScroll(initialScrollOffset, false);
+  }, [initialScrollOffset, requestScroll]);
+  (0, import_react.useEffect)(() => {
+    nearEndRef.current = false;
+  }, [horizontal, renderedItems.length, resolvedEndReachedThreshold]);
+  (0, import_react.useEffect)(() => {
+    const measureViewport = () => {
+      var _a2, _b2;
+      const query = (_b2 = (_a2 = import_taro.default).createSelectorQuery) == null ? void 0 : _b2.call(_a2);
+      if (!query) return;
+      query.select(`#${scrollHostId}`).boundingClientRect((rect) => {
+        if (!rect || Array.isArray(rect)) return;
+        measuredViewportRef.current = {
+          width: finiteLength(rect.width),
+          height: finiteLength(rect.height)
+        };
+      });
+      query.exec();
+    };
+    measureViewport();
+  }, [horizontal, renderedItems.length, scrollHeight, height, scrollHostId]);
+  (0, import_react.useEffect)(() => {
+    if (!scrollRequest.target || scrollRequest.targetResolved || !scrollTargetId) return;
+    (0, import_scrollTargetMeasurement.measureScrollTarget)(scrollHostId, scrollTargetId, ({ hostOffset, hostRect, targetRect }) => {
+      const hostCoordinate = finiteCoordinate(horizontal ? hostRect == null ? void 0 : hostRect.left : hostRect == null ? void 0 : hostRect.top);
+      const targetCoordinate = finiteCoordinate(horizontal ? targetRect == null ? void 0 : targetRect.left : targetRect == null ? void 0 : targetRect.top);
+      if (hostCoordinate === null || targetCoordinate === null) return;
+      const currentOffset = normalizeScrollOffset(
+        Number(horizontal ? hostOffset == null ? void 0 : hostOffset.scrollLeft : hostOffset == null ? void 0 : hostOffset.scrollTop)
+      );
+      const offset = normalizeScrollOffset(currentOffset + targetCoordinate - hostCoordinate);
+      setScrollRequest(
+        (current) => current.sequence === scrollRequest.sequence && current.target !== null && !current.targetResolved ? { ...current, offset, targetResolved: true } : current
+      );
+    });
+  }, [
+    horizontal,
+    scrollHostId,
+    scrollRequest.sequence,
+    scrollRequest.target,
+    scrollRequest.targetResolved,
+    scrollTargetId
+  ]);
+  const emitEndReached = (0, import_react.useCallback)(() => {
+    if (!onEndReached || nearEndRef.current) return;
+    nearEndRef.current = true;
+    onEndReached();
+  }, [onEndReached]);
+  const handleRefresh = (0, import_react.useCallback)(() => {
+    if (refreshing) return;
+    onRefresh == null ? void 0 : onRefresh();
+  }, [onRefresh, refreshing]);
+  const handleScroll = (event) => {
+    const detail = event.detail;
+    const host = event.currentTarget;
+    const width = finiteLength(host.clientWidth) || finiteLength(host.offsetWidth) || measuredViewportRef.current.width || explicitPixelLength(style == null ? void 0 : style.width);
+    const resolvedHeight = finiteLength(host.clientHeight) || finiteLength(host.offsetHeight) || measuredViewportRef.current.height || explicitPixelLength(scrollHeight ?? height ?? (style == null ? void 0 : style.height));
+    const extent = horizontal ? detail.scrollWidth : detail.scrollHeight;
+    const viewport = horizontal ? width : resolvedHeight;
+    const offset = horizontal ? detail.scrollLeft : detail.scrollTop;
+    const distanceFromEnd = extent - viewport - offset;
+    const threshold = extent * resolvedEndReachedThreshold;
+    if (extent > 0 && extent !== measuredExtentRef.current) {
+      measuredExtentRef.current = extent;
+      setMeasuredExtent(extent);
+    }
+    onScroll == null ? void 0 : onScroll({
+      nativeEvent: {
+        contentOffset: { x: detail.scrollLeft, y: detail.scrollTop },
+        contentSize: { width: detail.scrollWidth, height: detail.scrollHeight },
+        layoutMeasurement: { width, height: resolvedHeight }
+      },
+      originalEvent: event
+    });
+    if (extent > 0 && viewport > 0) {
+      if (distanceFromEnd <= threshold) emitEndReached();
+      else nearEndRef.current = false;
+    }
+  };
+  const surfaceStyle = variant === "card" ? {
+    padding: 16,
+    borderRadius: "var(--x-list-card-radius)",
+    backgroundColor: theme.colors.card,
+    border: `1px solid ${theme.colors.border}`
+  } : variant === "outline" ? {
+    padding: 16,
+    borderRadius: "var(--x-list-card-radius)",
+    backgroundColor: theme.colors.background,
+    border: `1px solid ${theme.colors.border}`
+  } : void 0;
+  const headerNode = renderSlot(ListHeaderComponent !== void 0 ? ListHeaderComponent : header);
+  const footerNode = renderSlot(ListFooterComponent !== void 0 ? ListFooterComponent : footer);
+  const emptyNode = ListEmptyComponent !== void 0 ? renderSlot(ListEmptyComponent) : renderText(resolvedEmptyText, theme.colors);
+  const loadingNode = renderText(resolvedLoadingText, theme.colors);
+  const controlledOffset = scrollRequest.target === null || scrollRequest.targetResolved ? scrollRequest.offset + (scrollRequest.sequence % 2 === 0 ? 0 : 0.01) : void 0;
+  const estimatedExtent = estimateListExtent({
+    divider,
+    gap,
+    horizontal,
+    itemHeight,
+    itemCount: renderedItems.length,
+    numColumns: resolvedColumns
+  });
+  const nativeLowerThreshold = Math.max(
+    0,
+    Math.round((measuredExtent || estimatedExtent) * resolvedEndReachedThreshold)
+  );
+  const boundaryStyle = {
+    boxSizing: "border-box",
+    width: "100%",
+    minWidth: horizontal ? "100%" : 0,
+    flexShrink: 0
+  };
+  const resolvedStateStyle = { ...stateStyle, ...boundaryStyle };
+  return /* @__PURE__ */ import_react.default.createElement(
+    import_components.View,
+    {
+      "data-slot": "flat-list-root",
+      "data-columns": String(resolvedColumns),
+      "data-horizontal": horizontal ? "true" : void 0,
+      "data-native-lower-threshold": nativeLowerThreshold,
+      "data-refresh-enabled": onRefresh ? "true" : void 0,
+      "data-refreshing": refreshing ? "true" : void 0,
+      "data-scroll-target": scrollTargetId,
+      "data-testid": testID,
+      className: (0, import_utils.classNames)("x-flat-list", `x-flat-list--${variant}`, className),
+      style: { boxSizing: "border-box", width: "100%", ...style }
+    },
+    /* @__PURE__ */ import_react.default.createElement(
+      import_scrollView.ScrollView,
+      {
+        id: scrollHostId,
+        className: "x-flat-list__scroll",
+        horizontal,
+        scrollX: horizontal,
+        scrollY: !horizontal,
+        flex: false,
+        height: scrollHeight ?? height ?? "auto",
+        scrollWithAnimation: scrollRequest.animated,
+        scrollIntoView: scrollRequest.targetResolved ? void 0 : scrollTargetId,
+        scrollIntoViewAlignment: "start",
+        scrollTop: horizontal ? void 0 : controlledOffset,
+        scrollLeft: horizontal ? controlledOffset : void 0,
+        showScrollbar,
+        lowerThreshold: nativeLowerThreshold,
+        refresherEnabled: Boolean(onRefresh),
+        refresherTriggered: refreshing,
+        refreshing,
+        refreshControl: onRefresh ? /* @__PURE__ */ import_react.default.createElement(import_components.Text, { className: "x-flat-list__refresh-text" }, resolvedRefreshText) : null,
+        onRefresherRefresh: onRefresh ? handleRefresh : void 0,
+        onScrollToLower: onEndReached ? emitEndReached : void 0,
+        onScroll: handleScroll
+      },
+      /* @__PURE__ */ import_react.default.createElement(
+        import_components.View,
+        {
+          "data-slot": "flat-list-content",
+          className: "x-flat-list__content",
+          style: {
+            boxSizing: "border-box",
+            display: "flex",
+            width: "100%",
+            minWidth: 0,
+            flexDirection: horizontal ? "row" : "column",
+            ...contentContainerStyle
+          }
+        },
+        /* @__PURE__ */ import_react.default.createElement(
+          import_components.View,
+          {
+            id: ((_a = scrollRequest.target) == null ? void 0 : _a.type) === "start" ? scrollTargetId : `${instanceIdRef.current}-start`,
+            "aria-hidden": true,
+            "data-slot": "flat-list-start",
+            style: anchorStyle
+          }
+        ),
+        hasRenderableNode(headerNode) ? /* @__PURE__ */ import_react.default.createElement(
+          import_components.View,
+          {
+            "data-slot": "flat-list-header",
+            className: "x-flat-list__header",
+            style: boundaryStyle
+          },
+          headerNode
+        ) : null,
+        loading && renderedItems.length === 0 ? /* @__PURE__ */ import_react.default.createElement(
+          import_components.View,
+          {
+            "data-slot": "flat-list-loading",
+            className: "x-flat-list__loading",
+            style: resolvedStateStyle
+          },
+          loadingNode
+        ) : renderedItems.length === 0 ? /* @__PURE__ */ import_react.default.createElement(
+          import_components.View,
+          {
+            "data-slot": "flat-list-empty",
+            className: "x-flat-list__empty",
+            style: resolvedStateStyle
+          },
+          emptyNode
+        ) : /* @__PURE__ */ import_react.default.createElement(
+          import_components.View,
+          {
+            "data-slot": "flat-list-items",
+            className: "x-flat-list__items",
+            style: {
+              boxSizing: "border-box",
+              display: "flex",
+              width: horizontal ? void 0 : "100%",
+              minWidth: horizontal ? "100%" : 0,
+              flexShrink: horizontal ? 0 : void 0,
+              flexDirection: horizontal || resolvedColumns > 1 ? "row" : "column",
+              flexWrap: !horizontal && resolvedColumns > 1 ? "wrap" : "nowrap",
+              rowGap: !horizontal && resolvedColumns > 1 ? resolvedGap : void 0,
+              columnGap: horizontal || resolvedColumns > 1 ? resolvedGap : void 0
+            }
+          },
+          renderedItems.map((item, index) => {
+            var _a2;
+            return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, { key: item.key }, /* @__PURE__ */ import_react.default.createElement(
+              import_components.View,
+              {
+                id: ((_a2 = scrollRequest.target) == null ? void 0 : _a2.type) === "item" && scrollRequest.target.index === index ? scrollTargetId : `${instanceIdRef.current}-item-${index}`,
+                "data-slot": "flat-list-item",
+                "data-index": index,
+                className: (0, import_utils.classNames)(
+                  "x-flat-list__item",
+                  resolvedColumns > 1 && !horizontal && "x-flat-list__item--grid"
+                ),
+                style: {
+                  boxSizing: "border-box",
+                  width: !horizontal && resolvedColumns > 1 ? resolveGridItemWidth(resolvedColumns, gap) : void 0,
+                  flexShrink: horizontal ? 0 : void 0,
+                  ...surfaceStyle,
+                  ...itemStyle,
+                  ...item.style
+                }
+              },
+              item.node
+            ), divider && !horizontal && resolvedColumns === 1 && index < renderedItems.length - 1 ? /* @__PURE__ */ import_react.default.createElement(
+              import_components.View,
+              {
+                "data-slot": "flat-list-divider",
+                className: "x-flat-list__divider",
+                style: {
+                  margin: `${resolvedGap} ${toLength(dividerInset)}`,
+                  borderBottom: `1px solid ${theme.colors.border}`
+                }
+              }
+            ) : null);
+          })
+        ),
+        loading && renderedItems.length > 0 ? /* @__PURE__ */ import_react.default.createElement(
+          import_components.View,
+          {
+            "data-slot": "flat-list-loading",
+            className: "x-flat-list__loading",
+            style: resolvedStateStyle
+          },
+          loadingNode
+        ) : null,
+        hasRenderableNode(footerNode) ? /* @__PURE__ */ import_react.default.createElement(
+          import_components.View,
+          {
+            "data-slot": "flat-list-footer",
+            className: "x-flat-list__footer",
+            style: boundaryStyle
+          },
+          footerNode
+        ) : null,
+        /* @__PURE__ */ import_react.default.createElement(
+          import_components.View,
+          {
+            id: ((_b = scrollRequest.target) == null ? void 0 : _b.type) === "end" ? scrollTargetId : `${instanceIdRef.current}-end`,
+            "aria-hidden": true,
+            "data-slot": "flat-list-end",
+            style: anchorStyle
+          }
+        )
+      )
+    )
+  );
+}
+var stateStyle = {
+  boxSizing: "border-box",
+  display: "flex",
+  width: "100%",
+  alignItems: "center",
+  justifyContent: "center",
+  padding: 16
+};
+var anchorStyle = {
+  width: 0,
+  height: 0,
+  minWidth: 0,
+  minHeight: 0,
+  flexShrink: 0,
+  overflow: "hidden"
+};
+function renderListItem(renderer, item, index, colors) {
+  if (!renderer) return renderDefaultNode(item, colors);
+  if (renderer.length >= 2) {
+    return renderer(item, index);
+  }
+  return renderer({ item, index });
+}
+function renderSlot(slot) {
+  return typeof slot === "function" ? slot() : slot;
+}
+function renderText(content, colors) {
+  return typeof content === "string" || typeof content === "number" ? /* @__PURE__ */ import_react.default.createElement(import_components.Text, { style: { color: colors["muted-foreground"] } }, content) : content;
+}
+function resolveGridItemWidth(columns, gap) {
+  if (typeof gap === "number") return `calc((100% - ${(columns - 1) * gap}px) / ${columns})`;
+  return `calc((100% - (${columns - 1} * ${gap})) / ${columns})`;
+}
+function renderDefaultNode(item, colors) {
+  if (import_react.default.isValidElement(item)) return item;
+  if (typeof item === "string" || typeof item === "number") {
+    return /* @__PURE__ */ import_react.default.createElement(import_components.Text, { style: { color: colors.foreground } }, item);
+  }
+  if (item && typeof item === "object") {
+    const record = item;
+    const title = record.title ?? record.label ?? record.name;
+    const description = record.description ?? record.subtitle;
+    const extra = record.extra ?? record.value;
+    return /* @__PURE__ */ import_react.default.createElement(import_components.View, { style: { display: "flex", flexDirection: "column", gap: 6 } }, title !== void 0 ? /* @__PURE__ */ import_react.default.createElement(import_components.Text, { style: { color: colors.foreground, fontWeight: "600" } }, String(title)) : null, description !== void 0 ? /* @__PURE__ */ import_react.default.createElement(import_components.Text, { style: { color: colors["muted-foreground"], fontSize: 13 } }, String(description)) : null, extra !== void 0 ? /* @__PURE__ */ import_react.default.createElement(import_components.Text, { style: { color: colors.foreground } }, String(extra)) : null);
+  }
+  return null;
+}
+function toLength(value) {
+  return typeof value === "number" ? `${value}px` : value;
+}
+function hasRenderableNode(node) {
+  return node !== null && node !== void 0 && typeof node !== "boolean";
+}
+function normalizeScrollOffset(offset) {
+  return Number.isFinite(offset) ? Math.max(0, offset) : 0;
+}
+function normalizeEndReachedThreshold(threshold) {
+  if (!Number.isFinite(threshold)) return 0.2;
+  const normalized = threshold > 1 ? threshold / 100 : threshold;
+  return Math.min(1, Math.max(0, normalized));
+}
+function explicitPixelLength(value) {
+  if (typeof value === "number") return finiteLength(value);
+  if (typeof value !== "string") return 0;
+  const match = value.trim().match(/^(-?\d+(?:\.\d+)?)(?:px)?$/i);
+  return match ? finiteLength(Number.parseFloat(match[1])) : 0;
+}
+function finiteLength(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function finiteCoordinate(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function estimateListExtent({
+  divider,
+  gap,
+  horizontal,
+  itemHeight,
+  itemCount,
+  numColumns
+}) {
+  if (itemCount === 0) return 0;
+  const itemExtent = explicitPixelLength(itemHeight) || 50;
+  const gapExtent = explicitPixelLength(gap);
+  const axisItemCount = horizontal ? itemCount : Math.ceil(itemCount / numColumns);
+  const separatorExtent = horizontal || numColumns > 1 ? gapExtent : divider ? gapExtent * 2 + 1 : 0;
+  return axisItemCount * itemExtent + Math.max(0, axisItemCount - 1) * separatorExtent;
+}
+function resolveScrollTargetId(instanceId, target, sequence) {
+  if (!target) return void 0;
+  return `${instanceId}-${target.type}${target.type === "item" ? `-${target.index}` : ""}-${sequence}`;
+}
+var FlatList = import_react.default.forwardRef(FlatListInner);
+FlatList.displayName = "FlatList";
+var flatList_default = FlatList;

package/lib/components/flatList/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export { default as FlatList } from './flatList';
+export { default } from './flatList';
+//# sourceMappingURL=index.d.ts.map

package/lib/components/flatList/index.js

@@ -0,0 +1,44 @@
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+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);
+
+// src/components/flatList/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FlatList: () => import_flatList.default,
+  default: () => import_flatList2.default
+});
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./types"), module.exports);
+var import_flatList = __toESM(require("./flatList"));
+var import_flatList2 = __toESM(require("./flatList"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FlatList,
+  ...require("./types")
+});

package/lib/components/flatList/scrollTargetMeasurement.d.ts

@@ -0,0 +1,17 @@
+export interface ScrollTargetMeasurement {
+    hostOffset?: {
+        scrollLeft?: number;
+        scrollTop?: number;
+    } | null;
+    hostRect?: {
+        left?: number;
+        top?: number;
+    } | null;
+    targetRect?: {
+        left?: number;
+        top?: number;
+    } | null;
+}
+export declare type ScrollTargetMeasurementCallback = (measurement: ScrollTargetMeasurement) => void;
+export declare function measureScrollTarget(scrollHostId: string, scrollTargetId: string, callback: ScrollTargetMeasurementCallback): void;
+//# sourceMappingURL=scrollTargetMeasurement.d.ts.map

package/lib/components/flatList/scrollTargetMeasurement.h5.d.ts

@@ -0,0 +1,3 @@
+import type { ScrollTargetMeasurementCallback } from './scrollTargetMeasurement';
+export declare function measureScrollTarget(scrollHostId: string, scrollTargetId: string, callback: ScrollTargetMeasurementCallback): void;
+//# sourceMappingURL=scrollTargetMeasurement.h5.d.ts.map

package/lib/components/flatList/scrollTargetMeasurement.h5.js

@@ -0,0 +1,43 @@
+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);
+
+// src/components/flatList/scrollTargetMeasurement.h5.ts
+var scrollTargetMeasurement_h5_exports = {};
+__export(scrollTargetMeasurement_h5_exports, {
+  measureScrollTarget: () => measureScrollTarget
+});
+module.exports = __toCommonJS(scrollTargetMeasurement_h5_exports);
+function measureScrollTarget(scrollHostId, scrollTargetId, callback) {
+  const host = document.getElementById(scrollHostId);
+  const target = document.getElementById(scrollTargetId);
+  if (!host || !target) return;
+  const hostRect = host.getBoundingClientRect();
+  const targetRect = target.getBoundingClientRect();
+  callback({
+    hostRect,
+    hostOffset: {
+      scrollLeft: host.scrollLeft,
+      scrollTop: host.scrollTop
+    },
+    targetRect
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  measureScrollTarget
+});