@hanwenbo/x-taro-ui 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 hanwenbo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/es/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/es/adapters/miniapp/index.js

@@ -0,0 +1,9 @@
+/**
+ * Mini-program Platform Adapters
+ */
+
+export * from "./overlayHost";
+export * from "./portal";
+export * from "./measure";
+export * from "./scroll";
+export * from "./touch";

package/es/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/es/adapters/miniapp/measure.js

@@ -0,0 +1,135 @@
+/**
+ * Mini-program Measurement Utilities
+ * Node measurement for mini-program platform
+ */
+
+import Taro, { createSelectorQuery } from '@tarojs/taro';
+/**
+ * Measure a node by selector
+ */
+export function measureNode(selector) {
+  return new Promise(function (resolve) {
+    var query = createSelectorQuery();
+    query.select(selector).boundingClientRect();
+    query.exec(function (res) {
+      if (res[0]) {
+        var 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);
+      }
+    });
+  });
+}
+
+/**
+ * Measure multiple nodes
+ */
+export function measureNodes(selector) {
+  return new Promise(function (resolve) {
+    var query = createSelectorQuery();
+    query.selectAll(selector).boundingClientRect();
+    query.exec(function (res) {
+      if (res[0] && Array.isArray(res[0])) {
+        resolve(res[0].map(function (rect) {
+          return {
+            width: rect.width,
+            height: rect.height,
+            left: rect.left,
+            right: rect.right,
+            top: rect.top,
+            bottom: rect.bottom
+          };
+        }));
+      } else {
+        resolve([]);
+      }
+    });
+  });
+}
+
+/**
+ * Get viewport info
+ */
+export function getViewport() {
+  var runtimeViewport = globalThis;
+  var browserWidth = runtimeViewport.innerWidth;
+  var browserHeight = runtimeViewport.innerHeight;
+  var sysInfo = typeof Taro.getSystemInfoSync === 'function' ? Taro.getSystemInfoSync() : {
+    windowWidth: 375,
+    windowHeight: 667
+  };
+  var windowWidth = typeof browserWidth === 'number' && browserWidth > 0 ? browserWidth : sysInfo.windowWidth;
+  var windowHeight = typeof browserHeight === 'number' && browserHeight > 0 ? browserHeight : sysInfo.windowHeight;
+  return {
+    width: windowWidth,
+    height: windowHeight,
+    windowWidth: windowWidth,
+    windowHeight: windowHeight
+  };
+}
+
+/**
+ * Subscribe to viewport changes when the current runtime exposes DOM-style events.
+ * Mini-program runtimes safely fall back to a no-op subscription.
+ */
+export function subscribeViewportChange(listener) {
+  var runtimeViewport = globalThis;
+  if (typeof runtimeViewport.addEventListener !== 'function' || typeof runtimeViewport.removeEventListener !== 'function') {
+    return function () {
+      return undefined;
+    };
+  }
+  var active = true;
+  var animationFrame;
+  var requestFrame = runtimeViewport['requestAnimationFrame'];
+  var cancelFrame = runtimeViewport['cancelAnimationFrame'];
+  var handleViewportChange = function handleViewportChange() {
+    if (!active || animationFrame !== undefined) return;
+    if (typeof requestFrame !== 'function') {
+      listener();
+      return;
+    }
+    animationFrame = requestFrame.call(runtimeViewport, function () {
+      animationFrame = undefined;
+      if (active) listener();
+    });
+  };
+  runtimeViewport.addEventListener('scroll', handleViewportChange, true);
+  runtimeViewport.addEventListener('resize', handleViewportChange);
+  return function () {
+    var _runtimeViewport$remo, _runtimeViewport$remo2;
+    active = false;
+    (_runtimeViewport$remo = runtimeViewport.removeEventListener) === null || _runtimeViewport$remo === void 0 || _runtimeViewport$remo.call(runtimeViewport, 'scroll', handleViewportChange, true);
+    (_runtimeViewport$remo2 = runtimeViewport.removeEventListener) === null || _runtimeViewport$remo2 === void 0 || _runtimeViewport$remo2.call(runtimeViewport, 'resize', handleViewportChange);
+    if (animationFrame !== undefined) {
+      cancelFrame === null || cancelFrame === void 0 || cancelFrame.call(runtimeViewport, animationFrame);
+      animationFrame = undefined;
+    }
+  };
+}
+
+/**
+ * Convert px to rpx
+ */
+export function viewportPxToRpx(px) {
+  var _getViewport = getViewport(),
+    windowWidth = _getViewport.windowWidth;
+  return px / windowWidth * 750;
+}
+
+/**
+ * Convert rpx to px
+ */
+export function rpxToPx(rpx) {
+  var _getViewport2 = getViewport(),
+    windowWidth = _getViewport2.windowWidth;
+  return rpx / 750 * windowWidth;
+}

package/es/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/es/adapters/miniapp/overlayHost.js

@@ -0,0 +1,141 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+/**
+ * Mini-program Overlay Host
+ * Unified overlay container for mini-program platform
+ */
+
+import React, { useCallback, useEffect, useRef } from 'react';
+import { View } from '@tarojs/components';
+import { designSystemMotion } from "../../theme/generated/design-system.generated";
+import { getOverlayContentMotionStyle, getOverlayPositionStyle, useOverlayTransition } from "../../patterns/overlay";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Fragment as _Fragment } from "react/jsx-runtime";
+import { jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Overlay Host Component
+ * Manages backdrop and positioning for overlays
+ */
+export var OverlayHost = function OverlayHost(_ref) {
+  var visible = _ref.visible,
+    _ref$placement = _ref.placement,
+    placement = _ref$placement === void 0 ? 'center' : _ref$placement,
+    _ref$config = _ref.config,
+    config = _ref$config === void 0 ? {} : _ref$config,
+    children = _ref.children,
+    onBackdropClick = _ref.onBackdropClick,
+    onEscape = _ref.onEscape,
+    onClose = _ref.onClose,
+    afterClose = _ref.afterClose;
+  var _config$zIndex = config.zIndex,
+    zIndex = _config$zIndex === void 0 ? 1000 : _config$zIndex,
+    _config$backdrop = config.backdrop,
+    backdrop = _config$backdrop === void 0 ? true : _config$backdrop,
+    _config$closeOnBackdr = config.closeOnBackdrop,
+    closeOnBackdrop = _config$closeOnBackdr === void 0 ? true : _config$closeOnBackdr,
+    _config$closeOnEscape = config.closeOnEscape,
+    closeOnEscape = _config$closeOnEscape === void 0 ? false : _config$closeOnEscape,
+    _config$enterDuration = config.enterDuration,
+    enterDuration = _config$enterDuration === void 0 ? designSystemMotion.durationsMs.overlayEnter : _config$enterDuration,
+    _config$exitDuration = config.exitDuration,
+    exitDuration = _config$exitDuration === void 0 ? designSystemMotion.durationsMs.overlayExit : _config$exitDuration,
+    _config$contentAnimat = config.contentAnimation,
+    contentAnimation = _config$contentAnimat === void 0 ? 'auto' : _config$contentAnimat,
+    _config$backdropOpaci = config.backdropOpacity,
+    backdropOpacity = _config$backdropOpaci === void 0 ? 0.5 : _config$backdropOpaci,
+    _config$keepMounted = config.keepMounted,
+    keepMounted = _config$keepMounted === void 0 ? false : _config$keepMounted,
+    _config$disableBodySc = config.disableBodyScroll,
+    disableBodyScroll = _config$disableBodySc === void 0 ? backdrop : _config$disableBodySc,
+    backdropStyleOverride = config.backdropStyle,
+    contentStyleOverride = config.contentStyle;
+  var _useOverlayTransition = useOverlayTransition(visible, exitDuration, enterDuration),
+    shouldRender = _useOverlayTransition.shouldRender,
+    mounted = _useOverlayTransition.mounted,
+    settled = _useOverlayTransition.settled;
+  var previousVisibleRef = useRef(visible);
+  useEffect(function () {
+    var wasVisible = previousVisibleRef.current;
+    previousVisibleRef.current = visible;
+    if (!wasVisible || visible || !afterClose) return undefined;
+    var timer = setTimeout(afterClose, exitDuration);
+    return function () {
+      return clearTimeout(timer);
+    };
+  }, [afterClose, exitDuration, visible]);
+  useEffect(function () {
+    var runtimeDocument = globalThis['document'];
+    if (!visible || !disableBodyScroll || !(runtimeDocument !== null && runtimeDocument !== void 0 && runtimeDocument.body)) return undefined;
+    var previousOverflow = runtimeDocument.body.style.overflow;
+    runtimeDocument.body.style.overflow = 'hidden';
+    return function () {
+      runtimeDocument.body.style.overflow = previousOverflow;
+    };
+  }, [disableBodyScroll, visible]);
+  useEffect(function () {
+    var runtimeDocument = globalThis['document'];
+    if (!visible || !closeOnEscape || !(runtimeDocument !== null && runtimeDocument !== void 0 && runtimeDocument.addEventListener)) return undefined;
+    var handleKeyDown = function handleKeyDown(event) {
+      if (event.key !== 'Escape') return;
+      onEscape === null || onEscape === void 0 || onEscape();
+      onClose === null || onClose === void 0 || onClose();
+    };
+    runtimeDocument.addEventListener('keydown', handleKeyDown);
+    return function () {
+      return runtimeDocument.removeEventListener('keydown', handleKeyDown);
+    };
+  }, [closeOnEscape, onClose, onEscape, visible]);
+  var handleBackdropClick = useCallback(function () {
+    if (closeOnBackdrop) {
+      onBackdropClick === null || onBackdropClick === void 0 || onBackdropClick();
+      onClose === null || onClose === void 0 || onClose();
+    }
+  }, [closeOnBackdrop, onBackdropClick, onClose]);
+  if (!shouldRender && !keepMounted) {
+    return null;
+  }
+  var backdropStyle = _objectSpread({
+    position: 'fixed',
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0,
+    backgroundColor: 'var(--x-overlay-mask, #000000)',
+    opacity: mounted ? backdropOpacity : 0,
+    zIndex: zIndex,
+    transition: "opacity ".concat(mounted ? enterDuration : exitDuration, "ms ").concat(mounted ? designSystemMotion.easing.overlayEnter : designSystemMotion.easing.overlayExit),
+    pointerEvents: mounted ? 'auto' : 'none'
+  }, backdropStyleOverride);
+  var positionStyle = placement === 'center' ? {
+    top: '50%',
+    left: '50%'
+  } : getOverlayPositionStyle(placement);
+  var contentStyle = _objectSpread(_objectSpread(_objectSpread({
+    position: 'fixed',
+    zIndex: zIndex + 1
+  }, positionStyle), getOverlayContentMotionStyle(placement, mounted, contentAnimation, {
+    enter: enterDuration,
+    exit: exitDuration
+  }, settled)), {}, {
+    pointerEvents: mounted ? 'auto' : 'none',
+    visibility: shouldRender ? 'visible' : 'hidden'
+  }, contentStyleOverride);
+  return /*#__PURE__*/_jsxs(_Fragment, {
+    children: [backdrop && shouldRender ? /*#__PURE__*/_jsx(View, {
+      "data-slot": "overlay-backdrop",
+      style: backdropStyle,
+      onClick: handleBackdropClick,
+      catchMove: true
+    }) : null, /*#__PURE__*/_jsx(View, {
+      "data-slot": "overlay-content",
+      "aria-hidden": !visible,
+      style: contentStyle,
+      children: children
+    })]
+  });
+};
+export default OverlayHost;

package/es/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/es/adapters/miniapp/portal.js

@@ -0,0 +1,45 @@
+/**
+ * Mini-program Portal
+ * Content teleportation for mini-program
+ * Note: Mini-program doesn't support true portals, this is a shim
+ */
+
+import React from 'react';
+import * as TaroComponents from '@tarojs/components';
+import { Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
+var TaroRootPortal = TaroComponents.RootPortal;
+/**
+ * Portal Component (shim for mini-program)
+ * In mini-program, we can't truly portal outside component tree
+ * This provides API compatibility with web
+ */
+export var MiniappPortal = function MiniappPortal(_ref) {
+  var children = _ref.children;
+  // In mini-program, portal just renders children
+  // Actual overlay behavior is handled by OverlayHost
+  return /*#__PURE__*/_jsx(_Fragment, {
+    children: children
+  });
+};
+
+/**
+ * Root Portal Container
+ * Provides a mount point for overlays
+ */
+export var RootPortal = function RootPortal(_ref2) {
+  var children = _ref2.children,
+    _ref2$enable = _ref2.enable,
+    enable = _ref2$enable === void 0 ? true : _ref2$enable;
+  // RootPortal already lifts its complete subtree out of the page. Adding a
+  // fixed z-index wrapper here would create a second stacking context and cap
+  // the z-index chosen by Toast, Dialog, Tooltip and other overlay children.
+  if (!TaroRootPortal) return /*#__PURE__*/_jsx(_Fragment, {
+    children: children
+  });
+  return /*#__PURE__*/_jsx(TaroRootPortal, {
+    enable: enable,
+    children: children
+  });
+};
+export default MiniappPortal;

package/es/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/es/adapters/miniapp/scroll.js

@@ -0,0 +1,87 @@
+/**
+ * Mini-program Scroll Utilities
+ * Scroll handling for mini-program platform
+ */
+
+import { pageScrollTo, createSelectorQuery } from '@tarojs/taro';
+/**
+ * Scroll page to position
+ */
+export function scrollTo(options) {
+  return new Promise(function (resolve, reject) {
+    var _options$offsetTop, _options$offsetTop2, _options$duration;
+    pageScrollTo({
+      selector: options.selector,
+      scrollTop: options.selector ? undefined : (_options$offsetTop = options.offsetTop) !== null && _options$offsetTop !== void 0 ? _options$offsetTop : 0,
+      offsetTop: options.selector ? (_options$offsetTop2 = options.offsetTop) !== null && _options$offsetTop2 !== void 0 ? _options$offsetTop2 : 0 : undefined,
+      duration: (_options$duration = options.duration) !== null && _options$duration !== void 0 ? _options$duration : 300,
+      success: function success() {
+        return resolve();
+      },
+      fail: reject
+    });
+  });
+}
+
+/**
+ * Scroll to top
+ */
+export function scrollToTop() {
+  var duration = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 300;
+  return scrollTo({
+    duration: duration,
+    offsetTop: 0
+  });
+}
+
+/**
+ * Get scroll position of an element
+ */
+export function getScrollPosition(selector) {
+  return new Promise(function (resolve) {
+    var query = createSelectorQuery();
+    query.select(selector).scrollOffset();
+    query.exec(function (res) {
+      if (res[0]) {
+        resolve({
+          scrollTop: res[0].scrollTop,
+          scrollLeft: res[0].scrollLeft
+        });
+      } else {
+        resolve(null);
+      }
+    });
+  });
+}
+
+/**
+ * Throttle scroll handler for performance
+ */
+export function throttleScroll(handler) {
+  var wait = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100;
+  var lastTime;
+  var timeoutId = null;
+  var pendingScrollTop;
+  return function (scrollTop) {
+    var now = Date.now();
+    if (lastTime === undefined || now - lastTime >= wait) {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      pendingScrollTop = undefined;
+      lastTime = now;
+      handler(scrollTop);
+    } else {
+      pendingScrollTop = scrollTop;
+      if (timeoutId) return;
+      timeoutId = setTimeout(function () {
+        lastTime = Date.now();
+        timeoutId = null;
+        var nextScrollTop = pendingScrollTop;
+        pendingScrollTop = undefined;
+        if (nextScrollTop !== undefined) handler(nextScrollTop);
+      }, wait - (now - lastTime));
+    }
+  };
+}

package/es/adapters/miniapp/touch.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Mini-program Touch Utilities
+ * Touch event handling for mini-program platform
+ */
+export interface TouchInfo {
+    x: number;
+    y: number;
+    identifier: number;
+}
+export interface SwipeInfo {
+    direction: 'left' | 'right' | 'up' | 'down';
+    distance: number;
+    velocity: number;
+}
+export interface UseTouchOptions {
+    onTap?: () => void;
+    onLongPress?: () => void;
+    onSwipe?: (info: SwipeInfo) => void;
+    onTouchStart?: (touch: TouchInfo) => void;
+    onTouchMove?: (touch: TouchInfo, deltaX: number, deltaY: number) => void;
+    onTouchEnd?: () => void;
+    longPressDelay?: number;
+    swipeThreshold?: number;
+}
+/**
+ * Hook for touch handling
+ */
+export declare function useTouch(options?: UseTouchOptions): {
+    handlers: {
+        onTouchStart: (e: {
+            touches: {
+                clientX: number;
+                clientY: number;
+                identifier: number;
+            }[];
+        }) => void;
+        onTouchMove: (e: {
+            touches: {
+                clientX: number;
+                clientY: number;
+                identifier: number;
+            }[];
+        }) => void;
+        onTouchEnd: (e?: {
+            changedTouches?: {
+                clientX: number;
+                clientY: number;
+                identifier: number;
+            }[];
+        }) => void;
+    };
+};
+/**
+ * Detect swipe direction
+ */
+export declare function detectSwipe(startX: number, startY: number, endX: number, endY: number, threshold?: number): SwipeInfo | null;
+//# sourceMappingURL=touch.d.ts.map