gesture-kit-basic-touch 1.0.0

package/dist/DoubleTapGesture.d.ts

@@ -0,0 +1,6 @@
+/**
+ * DoubleTapGesture — Detects double tap gestures.
+ */
+import React from 'react';
+import type { DoubleTapProps } from './types';
+export declare const DoubleTapGesture: React.FC<DoubleTapProps>;

package/dist/DoubleTapGesture.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * DoubleTapGesture — Detects double tap gestures.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DoubleTapGesture = void 0;
+const react_1 = __importStar(require("react"));
+const react_native_gesture_handler_1 = require("react-native-gesture-handler");
+const DoubleTapGesture = ({ children, onDoubleTap, maxDelay, maxDistance, enabled = true, }) => {
+    const gesture = (0, react_1.useMemo)(() => {
+        let g = react_native_gesture_handler_1.Gesture.Tap().numberOfTaps(2);
+        if (maxDelay !== undefined)
+            g = g.maxDuration(maxDelay);
+        if (maxDistance !== undefined)
+            g = g.maxDistance(maxDistance);
+        g = g.onEnd((e) => {
+            const event = {
+                absoluteX: e.absoluteX, absoluteY: e.absoluteY,
+                x: e.x, y: e.y, numberOfTaps: 2,
+            };
+            onDoubleTap(event);
+        });
+        return g.enabled(enabled);
+    }, [onDoubleTap, maxDelay, maxDistance, enabled]);
+    return react_1.default.createElement(react_native_gesture_handler_1.GestureDetector, { gesture: gesture }, children);
+};
+exports.DoubleTapGesture = DoubleTapGesture;
+exports.DoubleTapGesture.displayName = 'DoubleTapGesture';

package/dist/LongPressGesture.d.ts

@@ -0,0 +1,6 @@
+/**
+ * LongPressGesture — Detects long press gestures.
+ */
+import React from 'react';
+import type { LongPressProps } from './types';
+export declare const LongPressGesture: React.FC<LongPressProps>;

package/dist/LongPressGesture.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * LongPressGesture — Detects long press gestures.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LongPressGesture = void 0;
+const react_1 = __importStar(require("react"));
+const react_native_gesture_handler_1 = require("react-native-gesture-handler");
+const LongPressGesture = ({ children, onLongPress, onPressIn, onPressOut, minDuration = 500, maxDistance, enabled = true, }) => {
+    const gesture = (0, react_1.useMemo)(() => {
+        let g = react_native_gesture_handler_1.Gesture.LongPress().minDuration(minDuration);
+        if (maxDistance !== undefined)
+            g = g.maxDistance(maxDistance);
+        if (onPressIn) {
+            g = g.onStart((e) => {
+                const event = {
+                    absoluteX: e.absoluteX, absoluteY: e.absoluteY,
+                    x: e.x, y: e.y, duration: e.duration,
+                };
+                onPressIn(event);
+            });
+        }
+        g = g.onEnd((e) => {
+            const event = {
+                absoluteX: e.absoluteX, absoluteY: e.absoluteY,
+                x: e.x, y: e.y, duration: e.duration,
+            };
+            onLongPress(event);
+        });
+        if (onPressOut) {
+            g = g.onFinalize((e) => {
+                const event = {
+                    absoluteX: e.absoluteX, absoluteY: e.absoluteY,
+                    x: e.x, y: e.y, duration: e.duration,
+                };
+                onPressOut(event);
+            });
+        }
+        return g.enabled(enabled);
+    }, [onLongPress, onPressIn, onPressOut, minDuration, maxDistance, enabled]);
+    return react_1.default.createElement(react_native_gesture_handler_1.GestureDetector, { gesture: gesture }, children);
+};
+exports.LongPressGesture = LongPressGesture;
+exports.LongPressGesture.displayName = 'LongPressGesture';

package/dist/PressForceGesture.d.ts

@@ -0,0 +1,6 @@
+/**
+ * PressForceGesture — Detects force/pressure touch gestures (3D Touch / Force Touch).
+ */
+import React from 'react';
+import type { PressForceProps } from './types';
+export declare const PressForceGesture: React.FC<PressForceProps>;

package/dist/PressForceGesture.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * PressForceGesture — Detects force/pressure touch gestures (3D Touch / Force Touch).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PressForceGesture = void 0;
+const react_1 = __importStar(require("react"));
+const react_native_gesture_handler_1 = require("react-native-gesture-handler");
+const PressForceGesture = ({ children, onPressForce, forceThreshold = 0.5, enabled = true, }) => {
+    const gesture = (0, react_1.useMemo)(() => {
+        const g = react_native_gesture_handler_1.Gesture.ForceTouch()
+            .minForce(forceThreshold)
+            .onStart((e) => {
+            const event = {
+                absoluteX: e.absoluteX, absoluteY: e.absoluteY,
+                x: e.x, y: e.y, force: e.force,
+            };
+            onPressForce(event);
+        })
+            .enabled(enabled);
+        return g;
+    }, [onPressForce, forceThreshold, enabled]);
+    return react_1.default.createElement(react_native_gesture_handler_1.GestureDetector, { gesture: gesture }, children);
+};
+exports.PressForceGesture = PressForceGesture;
+exports.PressForceGesture.displayName = 'PressForceGesture';

package/dist/QuadTapGesture.d.ts

@@ -0,0 +1,6 @@
+/**
+ * QuadTapGesture — Detects quad (four) tap gestures.
+ */
+import React from 'react';
+import type { QuadTapProps } from './types';
+export declare const QuadTapGesture: React.FC<QuadTapProps>;

package/dist/QuadTapGesture.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * QuadTapGesture — Detects quad (four) tap gestures.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuadTapGesture = void 0;
+const react_1 = __importStar(require("react"));
+const react_native_gesture_handler_1 = require("react-native-gesture-handler");
+const QuadTapGesture = ({ children, onQuadTap, maxDelay, maxDistance, enabled = true, }) => {
+    const gesture = (0, react_1.useMemo)(() => {
+        let g = react_native_gesture_handler_1.Gesture.Tap().numberOfTaps(4);
+        if (maxDelay !== undefined)
+            g = g.maxDuration(maxDelay);
+        if (maxDistance !== undefined)
+            g = g.maxDistance(maxDistance);
+        g = g.onEnd((e) => {
+            const event = {
+                absoluteX: e.absoluteX, absoluteY: e.absoluteY,
+                x: e.x, y: e.y, numberOfTaps: 4,
+            };
+            onQuadTap(event);
+        });
+        return g.enabled(enabled);
+    }, [onQuadTap, maxDelay, maxDistance, enabled]);
+    return react_1.default.createElement(react_native_gesture_handler_1.GestureDetector, { gesture: gesture }, children);
+};
+exports.QuadTapGesture = QuadTapGesture;
+exports.QuadTapGesture.displayName = 'QuadTapGesture';

package/dist/TapAndHoldGesture.d.ts

@@ -0,0 +1,6 @@
+/**
+ * TapAndHoldGesture — Detects a tap followed by a hold.
+ */
+import React from 'react';
+import type { TapAndHoldProps } from './types';
+export declare const TapAndHoldGesture: React.FC<TapAndHoldProps>;

package/dist/TapAndHoldGesture.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * TapAndHoldGesture — Detects a tap followed by a hold.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TapAndHoldGesture = void 0;
+const react_1 = __importStar(require("react"));
+const react_native_gesture_handler_1 = require("react-native-gesture-handler");
+const TapAndHoldGesture = ({ children, onTapAndHold, onTap, holdDuration = 500, enabled = true, }) => {
+    const gesture = (0, react_1.useMemo)(() => {
+        const holdGesture = react_native_gesture_handler_1.Gesture.LongPress()
+            .minDuration(holdDuration)
+            .onEnd((e) => {
+            const event = {
+                absoluteX: e.absoluteX, absoluteY: e.absoluteY,
+                x: e.x, y: e.y, duration: e.duration,
+            };
+            onTapAndHold(event);
+        })
+            .enabled(enabled);
+        if (onTap) {
+            const tapGesture = react_native_gesture_handler_1.Gesture.Tap()
+                .onEnd((e) => {
+                const event = {
+                    absoluteX: e.absoluteX, absoluteY: e.absoluteY,
+                    x: e.x, y: e.y, numberOfTaps: 1,
+                };
+                onTap(event);
+            })
+                .enabled(enabled);
+            return react_native_gesture_handler_1.Gesture.Exclusive(holdGesture, tapGesture);
+        }
+        return holdGesture;
+    }, [onTapAndHold, onTap, holdDuration, enabled]);
+    return react_1.default.createElement(react_native_gesture_handler_1.GestureDetector, { gesture: gesture }, children);
+};
+exports.TapAndHoldGesture = TapAndHoldGesture;
+exports.TapAndHoldGesture.displayName = 'TapAndHoldGesture';

package/dist/TapCancelGesture.d.ts

@@ -0,0 +1,6 @@
+/**
+ * TapCancelGesture — Detects when a tap is cancelled (finger moves away).
+ */
+import React from 'react';
+import type { TapCancelProps } from './types';
+export declare const TapCancelGesture: React.FC<TapCancelProps>;

package/dist/TapCancelGesture.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * TapCancelGesture — Detects when a tap is cancelled (finger moves away).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TapCancelGesture = void 0;
+const react_1 = __importStar(require("react"));
+const react_native_gesture_handler_1 = require("react-native-gesture-handler");
+const TapCancelGesture = ({ children, onTapCancel, onTapStart, maxDuration, enabled = true, }) => {
+    const gesture = (0, react_1.useMemo)(() => {
+        let g = react_native_gesture_handler_1.Gesture.Tap();
+        if (maxDuration !== undefined)
+            g = g.maxDuration(maxDuration);
+        if (onTapStart) {
+            g = g.onBegin((e) => {
+                const event = {
+                    absoluteX: e.absoluteX, absoluteY: e.absoluteY,
+                    x: e.x, y: e.y,
+                };
+                onTapStart(event);
+            });
+        }
+        g = g.onTouchesCancelled(() => {
+            onTapCancel({ absoluteX: 0, absoluteY: 0, x: 0, y: 0 });
+        });
+        return g.enabled(enabled);
+    }, [onTapCancel, onTapStart, maxDuration, enabled]);
+    return react_1.default.createElement(react_native_gesture_handler_1.GestureDetector, { gesture: gesture }, children);
+};
+exports.TapCancelGesture = TapCancelGesture;
+exports.TapCancelGesture.displayName = 'TapCancelGesture';

package/dist/TapGesture.d.ts

@@ -0,0 +1,6 @@
+/**
+ * TapGesture — Detects single tap gestures.
+ */
+import React from 'react';
+import type { TapProps } from './types';
+export declare const TapGesture: React.FC<TapProps>;

package/dist/TapGesture.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * TapGesture — Detects single tap gestures.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TapGesture = void 0;
+const react_1 = __importStar(require("react"));
+const react_native_gesture_handler_1 = require("react-native-gesture-handler");
+const TapGesture = ({ children, onTap, numberOfTaps = 1, maxDuration, maxDistance, enabled = true, }) => {
+    const gesture = (0, react_1.useMemo)(() => {
+        let g = react_native_gesture_handler_1.Gesture.Tap().numberOfTaps(numberOfTaps);
+        if (maxDuration !== undefined)
+            g = g.maxDuration(maxDuration);
+        if (maxDistance !== undefined)
+            g = g.maxDistance(maxDistance);
+        g = g.onEnd((e) => {
+            const event = {
+                absoluteX: e.absoluteX, absoluteY: e.absoluteY,
+                x: e.x, y: e.y, numberOfTaps,
+            };
+            onTap(event);
+        });
+        return g.enabled(enabled);
+    }, [onTap, numberOfTaps, maxDuration, maxDistance, enabled]);
+    return react_1.default.createElement(react_native_gesture_handler_1.GestureDetector, { gesture: gesture }, children);
+};
+exports.TapGesture = TapGesture;
+exports.TapGesture.displayName = 'TapGesture';

package/dist/TripleTapGesture.d.ts

@@ -0,0 +1,6 @@
+/**
+ * TripleTapGesture — Detects triple tap gestures.
+ */
+import React from 'react';
+import type { TripleTapProps } from './types';
+export declare const TripleTapGesture: React.FC<TripleTapProps>;

package/dist/TripleTapGesture.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * TripleTapGesture — Detects triple tap gestures.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TripleTapGesture = void 0;
+const react_1 = __importStar(require("react"));
+const react_native_gesture_handler_1 = require("react-native-gesture-handler");
+const TripleTapGesture = ({ children, onTripleTap, maxDelay, maxDistance, enabled = true, }) => {
+    const gesture = (0, react_1.useMemo)(() => {
+        let g = react_native_gesture_handler_1.Gesture.Tap().numberOfTaps(3);
+        if (maxDelay !== undefined)
+            g = g.maxDuration(maxDelay);
+        if (maxDistance !== undefined)
+            g = g.maxDistance(maxDistance);
+        g = g.onEnd((e) => {
+            const event = {
+                absoluteX: e.absoluteX, absoluteY: e.absoluteY,
+                x: e.x, y: e.y, numberOfTaps: 3,
+            };
+            onTripleTap(event);
+        });
+        return g.enabled(enabled);
+    }, [onTripleTap, maxDelay, maxDistance, enabled]);
+    return react_1.default.createElement(react_native_gesture_handler_1.GestureDetector, { gesture: gesture }, children);
+};
+exports.TripleTapGesture = TripleTapGesture;
+exports.TripleTapGesture.displayName = 'TripleTapGesture';

package/dist/VeryLongPressGesture.d.ts

@@ -0,0 +1,6 @@
+/**
+ * VeryLongPressGesture — Detects very long press gestures (default 1500ms).
+ */
+import React from 'react';
+import type { VeryLongPressProps } from './types';
+export declare const VeryLongPressGesture: React.FC<VeryLongPressProps>;

package/dist/VeryLongPressGesture.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * VeryLongPressGesture — Detects very long press gestures (default 1500ms).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VeryLongPressGesture = void 0;
+const react_1 = __importStar(require("react"));
+const react_native_gesture_handler_1 = require("react-native-gesture-handler");
+const VeryLongPressGesture = ({ children, onVeryLongPress, onPressIn, onPressOut, minDuration = 1500, maxDistance, enabled = true, }) => {
+    const gesture = (0, react_1.useMemo)(() => {
+        let g = react_native_gesture_handler_1.Gesture.LongPress().minDuration(minDuration);
+        if (maxDistance !== undefined)
+            g = g.maxDistance(maxDistance);
+        if (onPressIn) {
+            g = g.onStart((e) => {
+                const event = {
+                    absoluteX: e.absoluteX, absoluteY: e.absoluteY,
+                    x: e.x, y: e.y, duration: e.duration,
+                };
+                onPressIn(event);
+            });
+        }
+        g = g.onEnd((e) => {
+            const event = {
+                absoluteX: e.absoluteX, absoluteY: e.absoluteY,
+                x: e.x, y: e.y, duration: e.duration,
+            };
+            onVeryLongPress(event);
+        });
+        if (onPressOut) {
+            g = g.onFinalize((e) => {
+                const event = {
+                    absoluteX: e.absoluteX, absoluteY: e.absoluteY,
+                    x: e.x, y: e.y, duration: e.duration,
+                };
+                onPressOut(event);
+            });
+        }
+        return g.enabled(enabled);
+    }, [onVeryLongPress, onPressIn, onPressOut, minDuration, maxDistance, enabled]);
+    return react_1.default.createElement(react_native_gesture_handler_1.GestureDetector, { gesture: gesture }, children);
+};
+exports.VeryLongPressGesture = VeryLongPressGesture;
+exports.VeryLongPressGesture.displayName = 'VeryLongPressGesture';

package/dist/hooks/index.d.ts

@@ -0,0 +1,9 @@
+export { useTap } from './useTap';
+export { useDoubleTap } from './useDoubleTap';
+export { useTripleTap } from './useTripleTap';
+export { useQuadTap } from './useQuadTap';
+export { useLongPress } from './useLongPress';
+export { useVeryLongPress } from './useVeryLongPress';
+export { useTapAndHold } from './useTapAndHold';
+export { useTapCancel } from './useTapCancel';
+export { usePressForce } from './usePressForce';

package/dist/hooks/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePressForce = exports.useTapCancel = exports.useTapAndHold = exports.useVeryLongPress = exports.useLongPress = exports.useQuadTap = exports.useTripleTap = exports.useDoubleTap = exports.useTap = void 0;
+var useTap_1 = require("./useTap");
+Object.defineProperty(exports, "useTap", { enumerable: true, get: function () { return useTap_1.useTap; } });
+var useDoubleTap_1 = require("./useDoubleTap");
+Object.defineProperty(exports, "useDoubleTap", { enumerable: true, get: function () { return useDoubleTap_1.useDoubleTap; } });
+var useTripleTap_1 = require("./useTripleTap");
+Object.defineProperty(exports, "useTripleTap", { enumerable: true, get: function () { return useTripleTap_1.useTripleTap; } });
+var useQuadTap_1 = require("./useQuadTap");
+Object.defineProperty(exports, "useQuadTap", { enumerable: true, get: function () { return useQuadTap_1.useQuadTap; } });
+var useLongPress_1 = require("./useLongPress");
+Object.defineProperty(exports, "useLongPress", { enumerable: true, get: function () { return useLongPress_1.useLongPress; } });
+var useVeryLongPress_1 = require("./useVeryLongPress");
+Object.defineProperty(exports, "useVeryLongPress", { enumerable: true, get: function () { return useVeryLongPress_1.useVeryLongPress; } });
+var useTapAndHold_1 = require("./useTapAndHold");
+Object.defineProperty(exports, "useTapAndHold", { enumerable: true, get: function () { return useTapAndHold_1.useTapAndHold; } });
+var useTapCancel_1 = require("./useTapCancel");
+Object.defineProperty(exports, "useTapCancel", { enumerable: true, get: function () { return useTapCancel_1.useTapCancel; } });
+var usePressForce_1 = require("./usePressForce");
+Object.defineProperty(exports, "usePressForce", { enumerable: true, get: function () { return usePressForce_1.usePressForce; } });

package/dist/hooks/useDoubleTap.d.ts

@@ -0,0 +1,2 @@
+import type { UseDoubleTapOptions } from 'gesture-kit-core';
+export declare function useDoubleTap(options: UseDoubleTapOptions): import("react-native-gesture-handler/lib/typescript/handlers/gestures/tapGesture").TapGesture;

package/dist/hooks/useDoubleTap.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDoubleTap = useDoubleTap;
+/** useDoubleTap — Hook that returns a configured DoubleTap gesture. */
+const react_1 = require("react");
+const react_native_gesture_handler_1 = require("react-native-gesture-handler");
+function useDoubleTap(options) {
+    const { onDoubleTap, maxDelay, maxDistance, enabled = true } = options;
+    return (0, react_1.useMemo)(() => {
+        let g = react_native_gesture_handler_1.Gesture.Tap().numberOfTaps(2);
+        if (maxDelay !== undefined)
+            g = g.maxDuration(maxDelay);
+        if (maxDistance !== undefined)
+            g = g.maxDistance(maxDistance);
+        g = g.onEnd((e) => {
+            const event = { absoluteX: e.absoluteX, absoluteY: e.absoluteY, x: e.x, y: e.y, numberOfTaps: 2 };
+            onDoubleTap(event);
+        });
+        return g.enabled(enabled);
+    }, [onDoubleTap, maxDelay, maxDistance, enabled]);
+}

package/dist/hooks/useLongPress.d.ts

@@ -0,0 +1,2 @@
+import type { UseLongPressOptions } from 'gesture-kit-core';
+export declare function useLongPress(options: UseLongPressOptions): import("react-native-gesture-handler/lib/typescript/handlers/gestures/longPressGesture").LongPressGesture;

package/dist/hooks/useLongPress.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLongPress = useLongPress;
+/** useLongPress — Hook that returns a configured LongPress gesture. */
+const react_1 = require("react");
+const react_native_gesture_handler_1 = require("react-native-gesture-handler");
+function useLongPress(options) {
+    const { onLongPress, onPressIn, onPressOut, minDuration = 500, maxDistance, enabled = true } = options;
+    return (0, react_1.useMemo)(() => {
+        let g = react_native_gesture_handler_1.Gesture.LongPress().minDuration(minDuration);
+        if (maxDistance !== undefined)
+            g = g.maxDistance(maxDistance);
+        if (onPressIn) {
+            g = g.onStart((e) => {
+                const event = { absoluteX: e.absoluteX, absoluteY: e.absoluteY, x: e.x, y: e.y, duration: e.duration };
+                onPressIn(event);
+            });
+        }
+        g = g.onEnd((e) => {
+            const event = { absoluteX: e.absoluteX, absoluteY: e.absoluteY, x: e.x, y: e.y, duration: e.duration };
+            onLongPress(event);
+        });
+        if (onPressOut) {
+            g = g.onFinalize((e) => {
+                const event = { absoluteX: e.absoluteX, absoluteY: e.absoluteY, x: e.x, y: e.y, duration: e.duration };
+                onPressOut(event);
+            });
+        }
+        return g.enabled(enabled);
+    }, [onLongPress, onPressIn, onPressOut, minDuration, maxDistance, enabled]);
+}

package/dist/hooks/usePressForce.d.ts

@@ -0,0 +1,2 @@
+import type { UsePressForceOptions } from 'gesture-kit-core';
+export declare function usePressForce(options: UsePressForceOptions): import("react-native-gesture-handler/lib/typescript/handlers/gestures/forceTouchGesture").ForceTouchGesture;

package/dist/hooks/usePressForce.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePressForce = usePressForce;
+/** usePressForce — Hook for force/pressure touch. */
+const react_1 = require("react");
+const react_native_gesture_handler_1 = require("react-native-gesture-handler");
+function usePressForce(options) {
+    const { onPressForce, forceThreshold = 0.5, enabled = true } = options;
+    return (0, react_1.useMemo)(() => {
+        const g = react_native_gesture_handler_1.Gesture.ForceTouch()
+            .minForce(forceThreshold)
+            .onStart((e) => {
+            const event = { absoluteX: e.absoluteX, absoluteY: e.absoluteY, x: e.x, y: e.y, force: e.force };
+            onPressForce(event);
+        })
+            .enabled(enabled);
+        return g;
+    }, [onPressForce, forceThreshold, enabled]);
+}

package/dist/hooks/useQuadTap.d.ts

@@ -0,0 +1,2 @@
+import type { UseQuadTapOptions } from 'gesture-kit-core';
+export declare function useQuadTap(options: UseQuadTapOptions): import("react-native-gesture-handler/lib/typescript/handlers/gestures/tapGesture").TapGesture;

package/dist/hooks/useQuadTap.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useQuadTap = useQuadTap;
+/** useQuadTap — Hook that returns a configured QuadTap gesture. */
+const react_1 = require("react");
+const react_native_gesture_handler_1 = require("react-native-gesture-handler");
+function useQuadTap(options) {
+    const { onQuadTap, maxDelay, maxDistance, enabled = true } = options;
+    return (0, react_1.useMemo)(() => {
+        let g = react_native_gesture_handler_1.Gesture.Tap().numberOfTaps(4);
+        if (maxDelay !== undefined)
+            g = g.maxDuration(maxDelay);
+        if (maxDistance !== undefined)
+            g = g.maxDistance(maxDistance);
+        g = g.onEnd((e) => {
+            const event = { absoluteX: e.absoluteX, absoluteY: e.absoluteY, x: e.x, y: e.y, numberOfTaps: 4 };
+            onQuadTap(event);
+        });
+        return g.enabled(enabled);
+    }, [onQuadTap, maxDelay, maxDistance, enabled]);
+}

package/dist/hooks/useTap.d.ts

@@ -0,0 +1,2 @@
+import type { UseTapOptions } from 'gesture-kit-core';
+export declare function useTap(options: UseTapOptions): import("react-native-gesture-handler/lib/typescript/handlers/gestures/tapGesture").TapGesture;

package/dist/hooks/useTap.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTap = useTap;
+/** useTap — Hook that returns a configured Tap gesture. */
+const react_1 = require("react");
+const react_native_gesture_handler_1 = require("react-native-gesture-handler");
+function useTap(options) {
+    const { onTap, numberOfTaps = 1, maxDuration, maxDistance, enabled = true } = options;
+    return (0, react_1.useMemo)(() => {
+        let g = react_native_gesture_handler_1.Gesture.Tap().numberOfTaps(numberOfTaps);
+        if (maxDuration !== undefined)
+            g = g.maxDuration(maxDuration);
+        if (maxDistance !== undefined)
+            g = g.maxDistance(maxDistance);
+        g = g.onEnd((e) => {
+            const event = { absoluteX: e.absoluteX, absoluteY: e.absoluteY, x: e.x, y: e.y, numberOfTaps };
+            onTap(event);
+        });
+        return g.enabled(enabled);
+    }, [onTap, numberOfTaps, maxDuration, maxDistance, enabled]);
+}

package/dist/hooks/useTapAndHold.d.ts

@@ -0,0 +1,2 @@
+import type { UseTapAndHoldOptions } from 'gesture-kit-core';
+export declare function useTapAndHold(options: UseTapAndHoldOptions): import("react-native-gesture-handler/lib/typescript/handlers/gestures/longPressGesture").LongPressGesture | import("react-native-gesture-handler/lib/typescript/handlers/gestures/gestureComposition").ExclusiveGesture;

package/dist/hooks/useTapAndHold.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTapAndHold = useTapAndHold;
+/** useTapAndHold — Hook for tap then hold gesture. */
+const react_1 = require("react");
+const react_native_gesture_handler_1 = require("react-native-gesture-handler");
+function useTapAndHold(options) {
+    const { onTapAndHold, onTap, holdDuration = 500, enabled = true } = options;
+    return (0, react_1.useMemo)(() => {
+        const holdGesture = react_native_gesture_handler_1.Gesture.LongPress()
+            .minDuration(holdDuration)
+            .onEnd((e) => {
+            const event = { absoluteX: e.absoluteX, absoluteY: e.absoluteY, x: e.x, y: e.y, duration: e.duration };
+            onTapAndHold(event);
+        })
+            .enabled(enabled);
+        if (onTap) {
+            const tapGesture = react_native_gesture_handler_1.Gesture.Tap()
+                .onEnd((e) => {
+                const event = { absoluteX: e.absoluteX, absoluteY: e.absoluteY, x: e.x, y: e.y, numberOfTaps: 1 };
+                onTap(event);
+            })
+                .enabled(enabled);
+            return react_native_gesture_handler_1.Gesture.Exclusive(holdGesture, tapGesture);
+        }
+        return holdGesture;
+    }, [onTapAndHold, onTap, holdDuration, enabled]);
+}

package/dist/hooks/useTapCancel.d.ts

@@ -0,0 +1,2 @@
+import type { UseTapCancelOptions } from 'gesture-kit-core';
+export declare function useTapCancel(options: UseTapCancelOptions): import("react-native-gesture-handler/lib/typescript/handlers/gestures/tapGesture").TapGesture;

package/dist/hooks/useTapCancel.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTapCancel = useTapCancel;
+/** useTapCancel — Hook for detecting cancelled taps. */
+const react_1 = require("react");
+const react_native_gesture_handler_1 = require("react-native-gesture-handler");
+function useTapCancel(options) {
+    const { onTapCancel, onTapStart, maxDuration, enabled = true } = options;
+    return (0, react_1.useMemo)(() => {
+        let g = react_native_gesture_handler_1.Gesture.Tap();
+        if (maxDuration !== undefined)
+            g = g.maxDuration(maxDuration);
+        if (onTapStart) {
+            g = g.onBegin((e) => {
+                const event = { absoluteX: e.absoluteX, absoluteY: e.absoluteY, x: e.x, y: e.y };
+                onTapStart(event);
+            });
+        }
+        g = g.onTouchesCancelled(() => {
+            onTapCancel({ absoluteX: 0, absoluteY: 0, x: 0, y: 0 });
+        });
+        return g.enabled(enabled);
+    }, [onTapCancel, onTapStart, maxDuration, enabled]);
+}

package/dist/hooks/useTripleTap.d.ts

@@ -0,0 +1,2 @@
+import type { UseTripleTapOptions } from 'gesture-kit-core';
+export declare function useTripleTap(options: UseTripleTapOptions): import("react-native-gesture-handler/lib/typescript/handlers/gestures/tapGesture").TapGesture;

package/dist/hooks/useTripleTap.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTripleTap = useTripleTap;
+/** useTripleTap — Hook that returns a configured TripleTap gesture. */
+const react_1 = require("react");
+const react_native_gesture_handler_1 = require("react-native-gesture-handler");
+function useTripleTap(options) {
+    const { onTripleTap, maxDelay, maxDistance, enabled = true } = options;
+    return (0, react_1.useMemo)(() => {
+        let g = react_native_gesture_handler_1.Gesture.Tap().numberOfTaps(3);
+        if (maxDelay !== undefined)
+            g = g.maxDuration(maxDelay);
+        if (maxDistance !== undefined)
+            g = g.maxDistance(maxDistance);
+        g = g.onEnd((e) => {
+            const event = { absoluteX: e.absoluteX, absoluteY: e.absoluteY, x: e.x, y: e.y, numberOfTaps: 3 };
+            onTripleTap(event);
+        });
+        return g.enabled(enabled);
+    }, [onTripleTap, maxDelay, maxDistance, enabled]);
+}

package/dist/hooks/useVeryLongPress.d.ts

@@ -0,0 +1,2 @@
+import type { UseVeryLongPressOptions } from 'gesture-kit-core';
+export declare function useVeryLongPress(options: UseVeryLongPressOptions): import("react-native-gesture-handler/lib/typescript/handlers/gestures/longPressGesture").LongPressGesture;

package/dist/hooks/useVeryLongPress.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useVeryLongPress = useVeryLongPress;
+/** useVeryLongPress — Hook for very long press (default 1500ms). */
+const react_1 = require("react");
+const react_native_gesture_handler_1 = require("react-native-gesture-handler");
+function useVeryLongPress(options) {
+    const { onVeryLongPress, onPressIn, onPressOut, minDuration = 1500, maxDistance, enabled = true } = options;
+    return (0, react_1.useMemo)(() => {
+        let g = react_native_gesture_handler_1.Gesture.LongPress().minDuration(minDuration);
+        if (maxDistance !== undefined)
+            g = g.maxDistance(maxDistance);
+        if (onPressIn) {
+            g = g.onStart((e) => {
+                const event = { absoluteX: e.absoluteX, absoluteY: e.absoluteY, x: e.x, y: e.y, duration: e.duration };
+                onPressIn(event);
+            });
+        }
+        g = g.onEnd((e) => {
+            const event = { absoluteX: e.absoluteX, absoluteY: e.absoluteY, x: e.x, y: e.y, duration: e.duration };
+            onVeryLongPress(event);
+        });
+        if (onPressOut) {
+            g = g.onFinalize((e) => {
+                const event = { absoluteX: e.absoluteX, absoluteY: e.absoluteY, x: e.x, y: e.y, duration: e.duration };
+                onPressOut(event);
+            });
+        }
+        return g.enabled(enabled);
+    }, [onVeryLongPress, onPressIn, onPressOut, minDuration, maxDistance, enabled]);
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from './types';
+export { TapGesture } from './TapGesture';
+export { DoubleTapGesture } from './DoubleTapGesture';
+export { TripleTapGesture } from './TripleTapGesture';
+export { QuadTapGesture } from './QuadTapGesture';
+export { LongPressGesture } from './LongPressGesture';
+export { VeryLongPressGesture } from './VeryLongPressGesture';
+export { TapAndHoldGesture } from './TapAndHoldGesture';
+export { TapCancelGesture } from './TapCancelGesture';
+export { PressForceGesture } from './PressForceGesture';
+export * from './hooks';

package/dist/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PressForceGesture = exports.TapCancelGesture = exports.TapAndHoldGesture = exports.VeryLongPressGesture = exports.LongPressGesture = exports.QuadTapGesture = exports.TripleTapGesture = exports.DoubleTapGesture = exports.TapGesture = void 0;
+// Basic Touch Gestures
+__exportStar(require("./types"), exports);
+// Components
+var TapGesture_1 = require("./TapGesture");
+Object.defineProperty(exports, "TapGesture", { enumerable: true, get: function () { return TapGesture_1.TapGesture; } });
+var DoubleTapGesture_1 = require("./DoubleTapGesture");
+Object.defineProperty(exports, "DoubleTapGesture", { enumerable: true, get: function () { return DoubleTapGesture_1.DoubleTapGesture; } });
+var TripleTapGesture_1 = require("./TripleTapGesture");
+Object.defineProperty(exports, "TripleTapGesture", { enumerable: true, get: function () { return TripleTapGesture_1.TripleTapGesture; } });
+var QuadTapGesture_1 = require("./QuadTapGesture");
+Object.defineProperty(exports, "QuadTapGesture", { enumerable: true, get: function () { return QuadTapGesture_1.QuadTapGesture; } });
+var LongPressGesture_1 = require("./LongPressGesture");
+Object.defineProperty(exports, "LongPressGesture", { enumerable: true, get: function () { return LongPressGesture_1.LongPressGesture; } });
+var VeryLongPressGesture_1 = require("./VeryLongPressGesture");
+Object.defineProperty(exports, "VeryLongPressGesture", { enumerable: true, get: function () { return VeryLongPressGesture_1.VeryLongPressGesture; } });
+var TapAndHoldGesture_1 = require("./TapAndHoldGesture");
+Object.defineProperty(exports, "TapAndHoldGesture", { enumerable: true, get: function () { return TapAndHoldGesture_1.TapAndHoldGesture; } });
+var TapCancelGesture_1 = require("./TapCancelGesture");
+Object.defineProperty(exports, "TapCancelGesture", { enumerable: true, get: function () { return TapCancelGesture_1.TapCancelGesture; } });
+var PressForceGesture_1 = require("./PressForceGesture");
+Object.defineProperty(exports, "PressForceGesture", { enumerable: true, get: function () { return PressForceGesture_1.PressForceGesture; } });
+// Hooks
+__exportStar(require("./hooks"), exports);

package/dist/types.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Types for Basic Touch gestures.
+ */
+import type { BaseGestureEvent, BaseGestureProps, TapEvent, LongPressEvent } from 'gesture-kit-core';
+export interface PressForceEvent extends BaseGestureEvent {
+    force: number;
+}
+export interface TapProps extends BaseGestureProps {
+    onTap: (event: TapEvent) => void;
+    numberOfTaps?: number;
+    maxDuration?: number;
+    maxDistance?: number;
+}
+export interface DoubleTapProps extends BaseGestureProps {
+    onDoubleTap: (event: TapEvent) => void;
+    maxDelay?: number;
+    maxDistance?: number;
+}
+export interface TripleTapProps extends BaseGestureProps {
+    onTripleTap: (event: TapEvent) => void;
+    maxDelay?: number;
+    maxDistance?: number;
+}
+export interface QuadTapProps extends BaseGestureProps {
+    onQuadTap: (event: TapEvent) => void;
+    maxDelay?: number;
+    maxDistance?: number;
+}
+export interface LongPressProps extends BaseGestureProps {
+    onLongPress: (event: LongPressEvent) => void;
+    onPressIn?: (event: LongPressEvent) => void;
+    onPressOut?: (event: LongPressEvent) => void;
+    minDuration?: number;
+    maxDistance?: number;
+}
+export interface VeryLongPressProps extends BaseGestureProps {
+    onVeryLongPress: (event: LongPressEvent) => void;
+    onPressIn?: (event: LongPressEvent) => void;
+    onPressOut?: (event: LongPressEvent) => void;
+    minDuration?: number;
+    maxDistance?: number;
+}
+export interface TapAndHoldProps extends BaseGestureProps {
+    onTapAndHold: (event: LongPressEvent) => void;
+    onTap?: (event: TapEvent) => void;
+    holdDuration?: number;
+}
+export interface TapCancelProps extends BaseGestureProps {
+    onTapCancel: (event: BaseGestureEvent) => void;
+    onTapStart?: (event: BaseGestureEvent) => void;
+    maxDuration?: number;
+}
+export interface PressForceProps extends BaseGestureProps {
+    onPressForce: (event: PressForceEvent) => void;
+    forceThreshold?: number;
+}
+export interface UseTripleTapOptions {
+    onTripleTap: (event: TapEvent) => void;
+    maxDelay?: number;
+    maxDistance?: number;
+    enabled?: boolean;
+}
+export interface UseQuadTapOptions {
+    onQuadTap: (event: TapEvent) => void;
+    maxDelay?: number;
+    maxDistance?: number;
+    enabled?: boolean;
+}
+export interface UseVeryLongPressOptions {
+    onVeryLongPress: (event: LongPressEvent) => void;
+    onPressIn?: (event: LongPressEvent) => void;
+    onPressOut?: (event: LongPressEvent) => void;
+    minDuration?: number;
+    maxDistance?: number;
+    enabled?: boolean;
+}
+export interface UseTapAndHoldOptions {
+    onTapAndHold: (event: LongPressEvent) => void;
+    onTap?: (event: TapEvent) => void;
+    holdDuration?: number;
+    enabled?: boolean;
+}
+export interface UseTapCancelOptions {
+    onTapCancel: (event: BaseGestureEvent) => void;
+    onTapStart?: (event: BaseGestureEvent) => void;
+    maxDuration?: number;
+    enabled?: boolean;
+}
+export interface UsePressForceOptions {
+    onPressForce: (event: PressForceEvent) => void;
+    forceThreshold?: number;
+    enabled?: boolean;
+}

package/dist/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Types for Basic Touch gestures.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "gesture-kit-basic-touch",
+  "version": "1.0.0",
+  "description": "Basic touch gestures: tap, double-tap, long-press, and more",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist", "README.md"],
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "gesture-kit-core": "^1.0.0"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-native": ">=0.71.0",
+    "react-native-gesture-handler": ">=2.10.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.2.0",
+    "react": "^18.2.0",
+    "react-native": "^0.73.11",
+    "react-native-gesture-handler": "^2.30.0",
+    "typescript": "^5.9.3"
+  },
+  "keywords": ["react-native", "gesture", "tap", "long-press", "double-tap"],
+  "license": "MIT"
+}