gesture-kit-core 1.0.0

package/README.md

@@ -0,0 +1,33 @@
+# gesture-kit-core
+
+Core types, utilities, and gesture composition for the Gesture Kit ecosystem.
+
+## Installation
+
+```bash
+npm install gesture-kit-core
+```
+
+### Peer Dependencies
+
+```bash
+npm install react-native-gesture-handler
+```
+
+## What's Included
+
+- **Types**: `GestureState`, `BaseGestureEvent`, `TapEvent`, `PanEvent`, `PinchEvent`, `RotationEvent`, etc.
+- **GestureComposer**: A declarative component for composing multiple gestures.
+- **createGestureComponent**: Factory function for creating custom gesture components.
+- **Utilities**: `composeGestures`, `detectSwipeDirection`, `matchesDirection`, `magnitude`.
+
+## Usage
+
+```tsx
+import { GestureComposer, composeGestures } from 'gesture-kit-core';
+import type { TapEvent, PanEvent } from 'gesture-kit-core';
+```
+
+## License
+
+MIT

package/dist/core/GestureComposer.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export declare const GestureComposer: React.FC<{
+    children: React.ReactNode;
+}>;

package/dist/core/GestureComposer.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GestureComposer = void 0;
+const react_1 = __importDefault(require("react"));
+const GestureComposer = ({ children }) => {
+    return react_1.default.createElement(react_1.default.Fragment, null, children);
+};
+exports.GestureComposer = GestureComposer;

package/dist/core/createGestureComponent.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export declare function createGestureComponent<T>(name: string): React.FC<T & {
+    children?: React.ReactNode;
+}>;

package/dist/core/createGestureComponent.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGestureComponent = createGestureComponent;
+const react_1 = __importDefault(require("react"));
+function createGestureComponent(name) {
+    const Component = ({ children }) => {
+        return react_1.default.createElement(react_1.default.Fragment, null, children);
+    };
+    Component.displayName = name;
+    return Component;
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * gesture-kit-core
+ *
+ * Core types, utilities, and composition for gesture-kit.
+ *
+ * @packageDocumentation
+ */
+export * from './types';
+export { GestureComposer, GestureComposer as Gesture } from './core/GestureComposer';
+export { createGestureComponent } from './core/createGestureComponent';
+export { detectSwipeDirection, matchesDirection, magnitude } from './utils/direction';
+export { composeGestures } from './utils/compose';
+export type { AnyGesture } from './utils/compose';

package/dist/index.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * gesture-kit-core
+ *
+ * Core types, utilities, and composition for gesture-kit.
+ *
+ * @packageDocumentation
+ */
+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.composeGestures = exports.magnitude = exports.matchesDirection = exports.detectSwipeDirection = exports.createGestureComponent = exports.Gesture = exports.GestureComposer = void 0;
+// ─── Types ──────────────────────────────────────────────────────────
+__exportStar(require("./types"), exports);
+// ─── Core ───────────────────────────────────────────────────────────
+var GestureComposer_1 = require("./core/GestureComposer");
+Object.defineProperty(exports, "GestureComposer", { enumerable: true, get: function () { return GestureComposer_1.GestureComposer; } });
+Object.defineProperty(exports, "Gesture", { enumerable: true, get: function () { return GestureComposer_1.GestureComposer; } });
+var createGestureComponent_1 = require("./core/createGestureComponent");
+Object.defineProperty(exports, "createGestureComponent", { enumerable: true, get: function () { return createGestureComponent_1.createGestureComponent; } });
+// ─── Utilities ──────────────────────────────────────────────────────
+var direction_1 = require("./utils/direction");
+Object.defineProperty(exports, "detectSwipeDirection", { enumerable: true, get: function () { return direction_1.detectSwipeDirection; } });
+Object.defineProperty(exports, "matchesDirection", { enumerable: true, get: function () { return direction_1.matchesDirection; } });
+Object.defineProperty(exports, "magnitude", { enumerable: true, get: function () { return direction_1.magnitude; } });
+var compose_1 = require("./utils/compose");
+Object.defineProperty(exports, "composeGestures", { enumerable: true, get: function () { return compose_1.composeGestures; } });

package/dist/types/gestures.d.ts

@@ -0,0 +1,304 @@
+/**
+ * Core gesture types and interfaces for react-native-gesture-kit.
+ *
+ * @module types/gestures
+ */
+/** All possible states of a gesture recognizer */
+export declare enum GestureState {
+    UNDETERMINED = 0,
+    BEGAN = 1,
+    ACTIVE = 2,
+    END = 3,
+    CANCELLED = 4,
+    FAILED = 5
+}
+/** Swipe direction */
+export type SwipeDirection = 'left' | 'right' | 'up' | 'down';
+/** Fling direction using RNGH's direction constants */
+export type FlingDirection = 'left' | 'right' | 'up' | 'down';
+/** Gesture composition priority strategy  */
+export type GesturePriority = 'simultaneous' | 'exclusive' | 'race';
+/** 2D point */
+export interface Point {
+    x: number;
+    y: number;
+}
+/** Velocity vector */
+export interface Velocity {
+    x: number;
+    y: number;
+}
+/** Base event shared by all gestures */
+export interface BaseGestureEvent {
+    /** Absolute X position on screen */
+    absoluteX: number;
+    /** Absolute Y position on screen */
+    absoluteY: number;
+    /** X position relative to the handler view */
+    x: number;
+    /** Y position relative to the handler view */
+    y: number;
+}
+/** Tap event payload */
+export interface TapEvent extends BaseGestureEvent {
+    /** Number of taps detected */
+    numberOfTaps: number;
+}
+/** Long press event payload */
+export interface LongPressEvent extends BaseGestureEvent {
+    /** Duration of the long press in ms */
+    duration: number;
+}
+/** Pan event payload */
+export interface PanEvent extends BaseGestureEvent {
+    /** Translation from the starting point */
+    translationX: number;
+    translationY: number;
+    /** Current velocity */
+    velocityX: number;
+    velocityY: number;
+}
+/** Swipe event payload */
+export interface SwipeEvent extends BaseGestureEvent {
+    /** Detected swipe direction */
+    direction: SwipeDirection;
+    /** Swipe velocity */
+    velocity: number;
+    /** Translation distance */
+    distance: number;
+}
+/** Pinch event payload */
+export interface PinchEvent extends BaseGestureEvent {
+    /** Current scale factor */
+    scale: number;
+    /** Velocity of the pinch */
+    velocity: number;
+    /** Focal point of the pinch */
+    focalX: number;
+    focalY: number;
+}
+/** Rotation event payload */
+export interface RotationEvent extends BaseGestureEvent {
+    /** Current rotation in radians */
+    rotation: number;
+    /** Angular velocity */
+    velocity: number;
+    /** Anchor point */
+    anchorX: number;
+    anchorY: number;
+}
+/** Fling event payload */
+export interface FlingEvent extends BaseGestureEvent {
+    /** Direction of the fling */
+    direction: FlingDirection;
+}
+/** Common props shared by all gesture components */
+export interface BaseGestureProps {
+    /** Whether the gesture is enabled */
+    enabled?: boolean;
+    /** Children to wrap */
+    children: React.ReactNode;
+}
+/** TapGesture component props */
+export interface TapGestureProps extends BaseGestureProps {
+    /** Callback when tap is detected */
+    onTap: (event: TapEvent) => void;
+    /** Number of required taps (default: 1) */
+    numberOfTaps?: number;
+    /** Maximum duration of a tap in ms */
+    maxDuration?: number;
+    /** Maximum distance finger can travel */
+    maxDistance?: number;
+}
+/** DoubleTapGesture component props */
+export interface DoubleTapGestureProps extends BaseGestureProps {
+    /** Callback when double tap is detected */
+    onDoubleTap: (event: TapEvent) => void;
+    /** Maximum delay between taps in ms */
+    maxDelay?: number;
+    /** Maximum distance between taps */
+    maxDistance?: number;
+}
+/** LongPressGesture component props */
+export interface LongPressGestureProps extends BaseGestureProps {
+    /** Callback when long press is detected */
+    onLongPress: (event: LongPressEvent) => void;
+    /** Callback when press begins */
+    onPressIn?: (event: LongPressEvent) => void;
+    /** Callback when press ends */
+    onPressOut?: (event: LongPressEvent) => void;
+    /** Minimum duration to trigger (default: 500ms) */
+    minDuration?: number;
+    /** Maximum distance finger can travel */
+    maxDistance?: number;
+}
+/** SwipeGesture component props */
+export interface SwipeGestureProps extends BaseGestureProps {
+    /** Callback when swipe is detected */
+    onSwipe: (event: SwipeEvent) => void;
+    /** Required swipe direction (any if omitted) */
+    direction?: SwipeDirection;
+    /** Minimum distance to qualify as swipe (default: 50) */
+    threshold?: number;
+    /** Minimum velocity to qualify (default: 300) */
+    velocityThreshold?: number;
+}
+/** PanGesture component props */
+export interface PanGestureProps extends BaseGestureProps {
+    /** Callback when pan starts */
+    onPanStart?: (event: PanEvent) => void;
+    /** Callback during panning */
+    onPanMove?: (event: PanEvent) => void;
+    /** Callback when pan ends */
+    onPanEnd?: (event: PanEvent) => void;
+    /** Minimum distance to activate (default: 10) */
+    minDistance?: number;
+    /** Minimum number of pointers */
+    minPointers?: number;
+    /** Maximum number of pointers */
+    maxPointers?: number;
+}
+/** PinchGesture component props */
+export interface PinchGestureProps extends BaseGestureProps {
+    /** Callback when pinch starts */
+    onPinchStart?: (event: PinchEvent) => void;
+    /** Callback during pinching */
+    onPinch?: (event: PinchEvent) => void;
+    /** Callback when pinch ends */
+    onPinchEnd?: (event: PinchEvent) => void;
+}
+/** RotationGesture component props */
+export interface RotationGestureProps extends BaseGestureProps {
+    /** Callback when rotation starts */
+    onRotationStart?: (event: RotationEvent) => void;
+    /** Callback during rotation */
+    onRotation?: (event: RotationEvent) => void;
+    /** Callback when rotation ends */
+    onRotationEnd?: (event: RotationEvent) => void;
+}
+/** FlingGesture component props */
+export interface FlingGestureProps extends BaseGestureProps {
+    /** Callback when fling is detected */
+    onFling: (event: FlingEvent) => void;
+    /** Required fling direction */
+    direction?: FlingDirection;
+    /** Number of required touching pointers (default: 1) */
+    numberOfPointers?: number;
+}
+/** Props for the <Gesture> composer component */
+export interface GestureComposerProps extends BaseGestureProps {
+    /** Enable tap gesture */
+    tap?: boolean;
+    /** Enable double tap gesture */
+    doubleTap?: boolean;
+    /** Enable long press gesture */
+    longPress?: boolean;
+    /** Enable swipe gesture — pass true for any direction, or a specific direction */
+    swipe?: boolean | SwipeDirection;
+    /** Enable pan gesture */
+    pan?: boolean;
+    /** Enable pinch gesture */
+    pinch?: boolean;
+    /** Enable rotation gesture */
+    rotate?: boolean;
+    /** Enable fling gesture — pass true for any direction, or a specific direction */
+    fling?: boolean | FlingDirection;
+    /** How to compose multiple gestures */
+    priority?: GesturePriority;
+    onTap?: (event: TapEvent) => void;
+    onDoubleTap?: (event: TapEvent) => void;
+    onLongPress?: (event: LongPressEvent) => void;
+    onSwipe?: (event: SwipeEvent) => void;
+    onPanStart?: (event: PanEvent) => void;
+    onPanMove?: (event: PanEvent) => void;
+    onPanEnd?: (event: PanEvent) => void;
+    onPinchStart?: (event: PinchEvent) => void;
+    onPinch?: (event: PinchEvent) => void;
+    onPinchEnd?: (event: PinchEvent) => void;
+    onRotationStart?: (event: RotationEvent) => void;
+    onRotation?: (event: RotationEvent) => void;
+    onRotationEnd?: (event: RotationEvent) => void;
+    onFling?: (event: FlingEvent) => void;
+}
+/** Options for useTap hook */
+export interface UseTapOptions {
+    onTap: (event: TapEvent) => void;
+    numberOfTaps?: number;
+    maxDuration?: number;
+    maxDistance?: number;
+    enabled?: boolean;
+}
+/** Options for useDoubleTap hook */
+export interface UseDoubleTapOptions {
+    onDoubleTap: (event: TapEvent) => void;
+    maxDelay?: number;
+    maxDistance?: number;
+    enabled?: boolean;
+}
+/** Options for useLongPress hook */
+export interface UseLongPressOptions {
+    onLongPress: (event: LongPressEvent) => void;
+    onPressIn?: (event: LongPressEvent) => void;
+    onPressOut?: (event: LongPressEvent) => void;
+    minDuration?: number;
+    maxDistance?: number;
+    enabled?: boolean;
+}
+/** Options for useSwipe hook */
+export interface UseSwipeOptions {
+    onSwipe: (event: SwipeEvent) => void;
+    direction?: SwipeDirection;
+    threshold?: number;
+    velocityThreshold?: number;
+    enabled?: boolean;
+}
+/** Options for usePan hook */
+export interface UsePanOptions {
+    onPanStart?: (event: PanEvent) => void;
+    onPanMove?: (event: PanEvent) => void;
+    onPanEnd?: (event: PanEvent) => void;
+    minDistance?: number;
+    minPointers?: number;
+    maxPointers?: number;
+    enabled?: boolean;
+}
+/** Options for usePinch hook */
+export interface UsePinchOptions {
+    onPinchStart?: (event: PinchEvent) => void;
+    onPinch?: (event: PinchEvent) => void;
+    onPinchEnd?: (event: PinchEvent) => void;
+    enabled?: boolean;
+}
+/** Options for useRotation hook */
+export interface UseRotationOptions {
+    onRotationStart?: (event: RotationEvent) => void;
+    onRotation?: (event: RotationEvent) => void;
+    onRotationEnd?: (event: RotationEvent) => void;
+    enabled?: boolean;
+}
+/** Options for useFling hook */
+export interface UseFlingOptions {
+    onFling: (event: FlingEvent) => void;
+    direction?: FlingDirection;
+    numberOfPointers?: number;
+    enabled?: boolean;
+}
+/** Options for useGesture (composer) hook */
+export interface UseGestureOptions {
+    tap?: UseTapOptions;
+    doubleTap?: UseDoubleTapOptions;
+    longPress?: UseLongPressOptions;
+    swipe?: UseSwipeOptions;
+    pan?: UsePanOptions;
+    pinch?: UsePinchOptions;
+    rotation?: UseRotationOptions;
+    fling?: UseFlingOptions;
+    priority?: GesturePriority;
+}
+/** Configuration for createGestureComponent factory */
+export interface GestureComponentConfig<P> {
+    /** Display name of the component */
+    name: string;
+    /** Function that creates a RNGH gesture from the component props */
+    createGesture: (props: P) => import('react-native-gesture-handler').GestureType;
+}

package/dist/types/gestures.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * Core gesture types and interfaces for react-native-gesture-kit.
+ *
+ * @module types/gestures
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GestureState = void 0;
+// ─── Enums ────────────────────────────────────────────────────────────────────
+/** All possible states of a gesture recognizer */
+var GestureState;
+(function (GestureState) {
+    GestureState[GestureState["UNDETERMINED"] = 0] = "UNDETERMINED";
+    GestureState[GestureState["BEGAN"] = 1] = "BEGAN";
+    GestureState[GestureState["ACTIVE"] = 2] = "ACTIVE";
+    GestureState[GestureState["END"] = 3] = "END";
+    GestureState[GestureState["CANCELLED"] = 4] = "CANCELLED";
+    GestureState[GestureState["FAILED"] = 5] = "FAILED";
+})(GestureState || (exports.GestureState = GestureState = {}));

package/dist/types/index.d.ts

@@ -0,0 +1,55 @@
+export interface BaseGestureEvent {
+    [key: string]: any;
+}
+export interface BaseGestureProps {
+    [key: string]: any;
+}
+export interface UseTapOptions {
+    [key: string]: any;
+}
+export interface TapEvent {
+    [key: string]: any;
+}
+export interface UseDoubleTapOptions {
+    [key: string]: any;
+}
+export interface UseTripleTapOptions {
+    [key: string]: any;
+}
+export interface UseQuadTapOptions {
+    [key: string]: any;
+}
+export interface UseLongPressOptions {
+    [key: string]: any;
+}
+export interface LongPressEvent {
+    [key: string]: any;
+}
+export interface UseVeryLongPressOptions {
+    [key: string]: any;
+}
+export interface UsePressForceOptions {
+    [key: string]: any;
+}
+export interface PressForceEvent {
+    [key: string]: any;
+}
+export interface UseTapAndHoldOptions {
+    [key: string]: any;
+}
+export interface UseTapCancelOptions {
+    [key: string]: any;
+}
+export type SwipeDirection = 'up' | 'down' | 'left' | 'right';
+export interface PanEvent {
+    [key: string]: any;
+}
+export interface SwipeEvent {
+    [key: string]: any;
+}
+export interface UsePanOptions {
+    [key: string]: any;
+}
+export interface PinchEvent {
+    [key: string]: any;
+}

package/dist/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/compose.d.ts

@@ -0,0 +1,2 @@
+export type AnyGesture = any;
+export declare function composeGestures(...gestures: AnyGesture[]): any[];

package/dist/utils/compose.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeGestures = composeGestures;
+function composeGestures(...gestures) {
+    return gestures;
+}

package/dist/utils/direction.d.ts

@@ -0,0 +1,3 @@
+export declare function detectSwipeDirection(dx: number, dy: number): "left" | "right";
+export declare function matchesDirection(dir: string, expected: string): boolean;
+export declare function magnitude(dx: number, dy: number): number;

package/dist/utils/direction.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectSwipeDirection = detectSwipeDirection;
+exports.matchesDirection = matchesDirection;
+exports.magnitude = magnitude;
+function detectSwipeDirection(dx, dy) {
+    return dx > 0 ? 'right' : 'left';
+}
+function matchesDirection(dir, expected) {
+    return dir === expected;
+}
+function magnitude(dx, dy) {
+    return Math.sqrt(dx * dx + dy * dy);
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "gesture-kit-core",
+  "version": "1.0.0",
+  "description": "Core types, utilities, and composition for gesture-kit",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist", "README.md"],
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-native": ">=0.71.0",
+    "react-native-gesture-handler": ">=2.10.0"
+  },
+  "peerDependenciesMeta": {
+    "react-native-reanimated": {
+      "optional": true
+    }
+  },
+  "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", "core", "types"],
+  "license": "MIT"
+}