@hanwenbo/x-taro-ui 0.0.1

package/es/utils/taroProps.js

@@ -0,0 +1,62 @@
+function targetValue(target) {
+  var _target$getAttribute, _target$querySelector;
+  if (!target) return undefined;
+  if (target.value) return target.value;
+  var attributeValue = (_target$getAttribute = target.getAttribute) === null || _target$getAttribute === void 0 ? void 0 : _target$getAttribute.call(target, 'value');
+  if (attributeValue != null) return attributeValue;
+  var nestedValue = (_target$querySelector = target.querySelector) === null || _target$querySelector === void 0 || (_target$querySelector = _target$querySelector.call(target, 'input')) === null || _target$querySelector === void 0 ? void 0 : _target$querySelector.value;
+  return nestedValue !== null && nestedValue !== void 0 ? nestedValue : target.value;
+}
+function eventValue(event) {
+  var _ref, _ref2, _event$detail$value, _event$detail;
+  return (_ref = (_ref2 = (_event$detail$value = (_event$detail = event.detail) === null || _event$detail === void 0 ? void 0 : _event$detail.value) !== null && _event$detail$value !== void 0 ? _event$detail$value : targetValue(event.target)) !== null && _ref2 !== void 0 ? _ref2 : targetValue(event.currentTarget)) !== null && _ref !== void 0 ? _ref : '';
+}
+
+/**
+ * Taro 的小程序无障碍属性使用 camelCase，components-react 则会把它们
+ * 原样透传到 DOM。这里按编译目标选择属性，避免 H5 React 告警，同时保留
+ * WeApp 的 ariaRole/ariaLabel 语义。
+ */
+export function resolveTaroAccessibilityProps(role, ariaLabel) {
+  var taroEnvironment = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : process.env.TARO_ENV;
+  if (taroEnvironment === 'h5') {
+    return {
+      role: role,
+      'aria-label': ariaLabel
+    };
+  }
+  return {
+    role: role,
+    ariaRole: role,
+    ariaLabel: ariaLabel
+  };
+}
+
+/**
+ * Taro Input 的 readonly、placeholderStyle 和 ariaLabel 在 H5 与小程序端
+ * 使用不同属性；onConfirm 则统一走 Taro Input 自身派发的 confirm 事件。
+ */
+export function resolveTaroInputPlatformProps(options) {
+  var taroEnvironment = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : process.env.TARO_ENV;
+  var ariaLabel = options.ariaLabel,
+    _onConfirm = options.onConfirm,
+    placeholderColor = options.placeholderColor,
+    readOnly = options.readOnly;
+  if (taroEnvironment === 'h5') {
+    return {
+      readOnly: readOnly,
+      'aria-label': ariaLabel,
+      onConfirm: function onConfirm(event) {
+        return _onConfirm === null || _onConfirm === void 0 ? void 0 : _onConfirm(eventValue(event));
+      }
+    };
+  }
+  return {
+    readonly: readOnly,
+    placeholderStyle: "color: ".concat(placeholderColor, ";"),
+    ariaLabel: ariaLabel,
+    onConfirm: function onConfirm(event) {
+      return _onConfirm === null || _onConfirm === void 0 ? void 0 : _onConfirm(eventValue(event));
+    }
+  };
+}

package/lib/adapters/miniapp/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Mini-program Platform Adapters
+ */
+export * from './overlayHost';
+export * from './portal';
+export * from './measure';
+export * from './scroll';
+export * from './touch';
+//# sourceMappingURL=index.d.ts.map

package/lib/adapters/miniapp/index.js

@@ -0,0 +1,31 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/adapters/miniapp/index.ts
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("./overlayHost"), module.exports);
+__reExport(index_exports, require("./portal"), module.exports);
+__reExport(index_exports, require("./measure"), module.exports);
+__reExport(index_exports, require("./scroll"), module.exports);
+__reExport(index_exports, require("./touch"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./overlayHost"),
+  ...require("./portal"),
+  ...require("./measure"),
+  ...require("./scroll"),
+  ...require("./touch")
+});

package/lib/adapters/miniapp/measure.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Mini-program Measurement Utilities
+ * Node measurement for mini-program platform
+ */
+export interface MeasureResult {
+    width: number;
+    height: number;
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+}
+/**
+ * Measure a node by selector
+ */
+export declare function measureNode(selector: string): Promise<MeasureResult | null>;
+/**
+ * Measure multiple nodes
+ */
+export declare function measureNodes(selector: string): Promise<MeasureResult[]>;
+/**
+ * Get viewport info
+ */
+export declare function getViewport(): {
+    width: number;
+    height: number;
+    windowWidth: number;
+    windowHeight: number;
+};
+/**
+ * Subscribe to viewport changes when the current runtime exposes DOM-style events.
+ * Mini-program runtimes safely fall back to a no-op subscription.
+ */
+export declare function subscribeViewportChange(listener: () => void): () => void;
+/**
+ * Convert px to rpx
+ */
+export declare function viewportPxToRpx(px: number): number;
+/**
+ * Convert rpx to px
+ */
+export declare function rpxToPx(rpx: number): number;
+//# sourceMappingURL=measure.d.ts.map

package/lib/adapters/miniapp/measure.js

@@ -0,0 +1,147 @@
+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/adapters/miniapp/measure.ts
+var measure_exports = {};
+__export(measure_exports, {
+  getViewport: () => getViewport,
+  measureNode: () => measureNode,
+  measureNodes: () => measureNodes,
+  rpxToPx: () => rpxToPx,
+  subscribeViewportChange: () => subscribeViewportChange,
+  viewportPxToRpx: () => viewportPxToRpx
+});
+module.exports = __toCommonJS(measure_exports);
+var import_taro = __toESM(require("@tarojs/taro"));
+function measureNode(selector) {
+  return new Promise((resolve) => {
+    const query = (0, import_taro.createSelectorQuery)();
+    query.select(selector).boundingClientRect();
+    query.exec((res) => {
+      if (res[0]) {
+        const rect = res[0];
+        resolve({
+          width: rect.width,
+          height: rect.height,
+          left: rect.left,
+          right: rect.right,
+          top: rect.top,
+          bottom: rect.bottom
+        });
+      } else {
+        resolve(null);
+      }
+    });
+  });
+}
+function measureNodes(selector) {
+  return new Promise((resolve) => {
+    const query = (0, import_taro.createSelectorQuery)();
+    query.selectAll(selector).boundingClientRect();
+    query.exec((res) => {
+      if (res[0] && Array.isArray(res[0])) {
+        resolve(
+          res[0].map((rect) => ({
+            width: rect.width,
+            height: rect.height,
+            left: rect.left,
+            right: rect.right,
+            top: rect.top,
+            bottom: rect.bottom
+          }))
+        );
+      } else {
+        resolve([]);
+      }
+    });
+  });
+}
+function getViewport() {
+  const runtimeViewport = globalThis;
+  const browserWidth = runtimeViewport.innerWidth;
+  const browserHeight = runtimeViewport.innerHeight;
+  const sysInfo = typeof import_taro.default.getSystemInfoSync === "function" ? import_taro.default.getSystemInfoSync() : { windowWidth: 375, windowHeight: 667 };
+  const windowWidth = typeof browserWidth === "number" && browserWidth > 0 ? browserWidth : sysInfo.windowWidth;
+  const windowHeight = typeof browserHeight === "number" && browserHeight > 0 ? browserHeight : sysInfo.windowHeight;
+  return {
+    width: windowWidth,
+    height: windowHeight,
+    windowWidth,
+    windowHeight
+  };
+}
+function subscribeViewportChange(listener) {
+  const runtimeViewport = globalThis;
+  if (typeof runtimeViewport.addEventListener !== "function" || typeof runtimeViewport.removeEventListener !== "function") {
+    return () => void 0;
+  }
+  let active = true;
+  let animationFrame;
+  const requestFrame = runtimeViewport["requestAnimationFrame"];
+  const cancelFrame = runtimeViewport["cancelAnimationFrame"];
+  const handleViewportChange = () => {
+    if (!active || animationFrame !== void 0) return;
+    if (typeof requestFrame !== "function") {
+      listener();
+      return;
+    }
+    animationFrame = requestFrame.call(runtimeViewport, () => {
+      animationFrame = void 0;
+      if (active) listener();
+    });
+  };
+  runtimeViewport.addEventListener("scroll", handleViewportChange, true);
+  runtimeViewport.addEventListener("resize", handleViewportChange);
+  return () => {
+    var _a, _b;
+    active = false;
+    (_a = runtimeViewport.removeEventListener) == null ? void 0 : _a.call(runtimeViewport, "scroll", handleViewportChange, true);
+    (_b = runtimeViewport.removeEventListener) == null ? void 0 : _b.call(runtimeViewport, "resize", handleViewportChange);
+    if (animationFrame !== void 0) {
+      cancelFrame == null ? void 0 : cancelFrame.call(runtimeViewport, animationFrame);
+      animationFrame = void 0;
+    }
+  };
+}
+function viewportPxToRpx(px) {
+  const { windowWidth } = getViewport();
+  return px / windowWidth * 750;
+}
+function rpxToPx(rpx) {
+  const { windowWidth } = getViewport();
+  return rpx / 750 * windowWidth;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getViewport,
+  measureNode,
+  measureNodes,
+  rpxToPx,
+  subscribeViewportChange,
+  viewportPxToRpx
+});

package/lib/adapters/miniapp/overlayHost.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Mini-program Overlay Host
+ * Unified overlay container for mini-program platform
+ */
+import React from 'react';
+import type { OverlayPlacement, OverlayHostConfig } from '../../patterns/overlay';
+export interface OverlayHostProps {
+    visible: boolean;
+    placement?: OverlayPlacement;
+    config?: Partial<OverlayHostConfig>;
+    children: React.ReactNode;
+    onBackdropClick?: () => void;
+    onEscape?: () => void;
+    onClose?: () => void;
+    afterClose?: () => void;
+}
+/**
+ * Overlay Host Component
+ * Manages backdrop and positioning for overlays
+ */
+export declare const OverlayHost: React.FC<OverlayHostProps>;
+export default OverlayHost;
+//# sourceMappingURL=overlayHost.d.ts.map

package/lib/adapters/miniapp/overlayHost.js

@@ -0,0 +1,152 @@
+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/adapters/miniapp/overlayHost.tsx
+var overlayHost_exports = {};
+__export(overlayHost_exports, {
+  OverlayHost: () => OverlayHost,
+  default: () => overlayHost_default
+});
+module.exports = __toCommonJS(overlayHost_exports);
+var import_react = __toESM(require("react"));
+var import_components = require("@tarojs/components");
+var import_design_system = require("../../theme/generated/design-system.generated");
+var import_overlay = require("../../patterns/overlay");
+var OverlayHost = ({
+  visible,
+  placement = "center",
+  config = {},
+  children,
+  onBackdropClick,
+  onEscape,
+  onClose,
+  afterClose
+}) => {
+  const {
+    zIndex = 1e3,
+    backdrop = true,
+    closeOnBackdrop = true,
+    closeOnEscape = false,
+    enterDuration = import_design_system.designSystemMotion.durationsMs.overlayEnter,
+    exitDuration = import_design_system.designSystemMotion.durationsMs.overlayExit,
+    contentAnimation = "auto",
+    backdropOpacity = 0.5,
+    keepMounted = false,
+    disableBodyScroll = backdrop,
+    backdropStyle: backdropStyleOverride,
+    contentStyle: contentStyleOverride
+  } = config;
+  const { shouldRender, mounted, settled } = (0, import_overlay.useOverlayTransition)(
+    visible,
+    exitDuration,
+    enterDuration
+  );
+  const previousVisibleRef = (0, import_react.useRef)(visible);
+  (0, import_react.useEffect)(() => {
+    const wasVisible = previousVisibleRef.current;
+    previousVisibleRef.current = visible;
+    if (!wasVisible || visible || !afterClose) return void 0;
+    const timer = setTimeout(afterClose, exitDuration);
+    return () => clearTimeout(timer);
+  }, [afterClose, exitDuration, visible]);
+  (0, import_react.useEffect)(() => {
+    const runtimeDocument = globalThis["document"];
+    if (!visible || !disableBodyScroll || !(runtimeDocument == null ? void 0 : runtimeDocument.body)) return void 0;
+    const previousOverflow = runtimeDocument.body.style.overflow;
+    runtimeDocument.body.style.overflow = "hidden";
+    return () => {
+      runtimeDocument.body.style.overflow = previousOverflow;
+    };
+  }, [disableBodyScroll, visible]);
+  (0, import_react.useEffect)(() => {
+    const runtimeDocument = globalThis["document"];
+    if (!visible || !closeOnEscape || !(runtimeDocument == null ? void 0 : runtimeDocument.addEventListener)) return void 0;
+    const handleKeyDown = (event) => {
+      if (event.key !== "Escape") return;
+      onEscape == null ? void 0 : onEscape();
+      onClose == null ? void 0 : onClose();
+    };
+    runtimeDocument.addEventListener("keydown", handleKeyDown);
+    return () => runtimeDocument.removeEventListener("keydown", handleKeyDown);
+  }, [closeOnEscape, onClose, onEscape, visible]);
+  const handleBackdropClick = (0, import_react.useCallback)(() => {
+    if (closeOnBackdrop) {
+      onBackdropClick == null ? void 0 : onBackdropClick();
+      onClose == null ? void 0 : onClose();
+    }
+  }, [closeOnBackdrop, onBackdropClick, onClose]);
+  if (!shouldRender && !keepMounted) {
+    return null;
+  }
+  const backdropStyle = {
+    position: "fixed",
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0,
+    backgroundColor: "var(--x-overlay-mask, #000000)",
+    opacity: mounted ? backdropOpacity : 0,
+    zIndex,
+    transition: `opacity ${mounted ? enterDuration : exitDuration}ms ${mounted ? import_design_system.designSystemMotion.easing.overlayEnter : import_design_system.designSystemMotion.easing.overlayExit}`,
+    pointerEvents: mounted ? "auto" : "none",
+    ...backdropStyleOverride
+  };
+  const positionStyle = placement === "center" ? { top: "50%", left: "50%" } : (0, import_overlay.getOverlayPositionStyle)(placement);
+  const contentStyle = {
+    position: "fixed",
+    zIndex: zIndex + 1,
+    ...positionStyle,
+    ...(0, import_overlay.getOverlayContentMotionStyle)(
+      placement,
+      mounted,
+      contentAnimation,
+      {
+        enter: enterDuration,
+        exit: exitDuration
+      },
+      settled
+    ),
+    pointerEvents: mounted ? "auto" : "none",
+    visibility: shouldRender ? "visible" : "hidden",
+    ...contentStyleOverride
+  };
+  return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, backdrop && shouldRender ? /* @__PURE__ */ import_react.default.createElement(
+    import_components.View,
+    {
+      "data-slot": "overlay-backdrop",
+      style: backdropStyle,
+      onClick: handleBackdropClick,
+      catchMove: true
+    }
+  ) : null, /* @__PURE__ */ import_react.default.createElement(import_components.View, { "data-slot": "overlay-content", "aria-hidden": !visible, style: contentStyle }, children));
+};
+var overlayHost_default = OverlayHost;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OverlayHost
+});

package/lib/adapters/miniapp/portal.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Mini-program Portal
+ * Content teleportation for mini-program
+ * Note: Mini-program doesn't support true portals, this is a shim
+ */
+import React from 'react';
+export interface MiniappPortalProps {
+    children: React.ReactNode;
+    container?: HTMLElement | (() => HTMLElement) | null;
+}
+/**
+ * Portal Component (shim for mini-program)
+ * In mini-program, we can't truly portal outside component tree
+ * This provides API compatibility with web
+ */
+export declare const MiniappPortal: React.FC<MiniappPortalProps>;
+/**
+ * Root Portal Container
+ * Provides a mount point for overlays
+ */
+export declare const RootPortal: React.FC<{
+    children: React.ReactNode;
+    enable?: boolean;
+}>;
+export default MiniappPortal;
+//# sourceMappingURL=portal.d.ts.map

package/lib/adapters/miniapp/portal.js

@@ -0,0 +1,55 @@
+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/adapters/miniapp/portal.tsx
+var portal_exports = {};
+__export(portal_exports, {
+  MiniappPortal: () => MiniappPortal,
+  RootPortal: () => RootPortal2,
+  default: () => portal_default
+});
+module.exports = __toCommonJS(portal_exports);
+var import_react = __toESM(require("react"));
+var TaroComponents = __toESM(require("@tarojs/components"));
+var TaroRootPortal = TaroComponents.RootPortal;
+var MiniappPortal = ({ children }) => {
+  return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, children);
+};
+var RootPortal2 = ({
+  children,
+  enable = true
+}) => {
+  if (!TaroRootPortal) return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, children);
+  return /* @__PURE__ */ import_react.default.createElement(TaroRootPortal, { enable }, children);
+};
+var portal_default = MiniappPortal;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MiniappPortal,
+  RootPortal
+});

package/lib/adapters/miniapp/scroll.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Mini-program Scroll Utilities
+ * Scroll handling for mini-program platform
+ */
+export interface ScrollOptions {
+    duration?: number;
+    selector?: string;
+    offsetTop?: number;
+}
+/**
+ * Scroll page to position
+ */
+export declare function scrollTo(options: ScrollOptions): Promise<void>;
+/**
+ * Scroll to top
+ */
+export declare function scrollToTop(duration?: number): Promise<void>;
+/**
+ * Get scroll position of an element
+ */
+export declare function getScrollPosition(selector: string): Promise<{
+    scrollTop: number;
+    scrollLeft: number;
+} | null>;
+/**
+ * Throttle scroll handler for performance
+ */
+export declare function throttleScroll(handler: (scrollTop: number) => void, wait?: number): (scrollTop: number) => void;
+//# sourceMappingURL=scroll.d.ts.map

package/lib/adapters/miniapp/scroll.js

@@ -0,0 +1,96 @@
+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/adapters/miniapp/scroll.ts
+var scroll_exports = {};
+__export(scroll_exports, {
+  getScrollPosition: () => getScrollPosition,
+  scrollTo: () => scrollTo,
+  scrollToTop: () => scrollToTop,
+  throttleScroll: () => throttleScroll
+});
+module.exports = __toCommonJS(scroll_exports);
+var import_taro = require("@tarojs/taro");
+function scrollTo(options) {
+  return new Promise((resolve, reject) => {
+    (0, import_taro.pageScrollTo)({
+      selector: options.selector,
+      scrollTop: options.selector ? void 0 : options.offsetTop ?? 0,
+      offsetTop: options.selector ? options.offsetTop ?? 0 : void 0,
+      duration: options.duration ?? 300,
+      success: () => resolve(),
+      fail: reject
+    });
+  });
+}
+function scrollToTop(duration = 300) {
+  return scrollTo({ duration, offsetTop: 0 });
+}
+function getScrollPosition(selector) {
+  return new Promise((resolve) => {
+    const query = (0, import_taro.createSelectorQuery)();
+    query.select(selector).scrollOffset();
+    query.exec((res) => {
+      if (res[0]) {
+        resolve({
+          scrollTop: res[0].scrollTop,
+          scrollLeft: res[0].scrollLeft
+        });
+      } else {
+        resolve(null);
+      }
+    });
+  });
+}
+function throttleScroll(handler, wait = 100) {
+  let lastTime;
+  let timeoutId = null;
+  let pendingScrollTop;
+  return (scrollTop) => {
+    const now = Date.now();
+    if (lastTime === void 0 || now - lastTime >= wait) {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      pendingScrollTop = void 0;
+      lastTime = now;
+      handler(scrollTop);
+    } else {
+      pendingScrollTop = scrollTop;
+      if (timeoutId) return;
+      timeoutId = setTimeout(
+        () => {
+          lastTime = Date.now();
+          timeoutId = null;
+          const nextScrollTop = pendingScrollTop;
+          pendingScrollTop = void 0;
+          if (nextScrollTop !== void 0) handler(nextScrollTop);
+        },
+        wait - (now - lastTime)
+      );
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getScrollPosition,
+  scrollTo,
+  scrollToTop,
+  throttleScroll
+});