react-native-gtkx 0.2.0-alpha.2 → 0.3.0-alpha.1

package/dist/gesture-handler-compat/types.d.ts

@@ -0,0 +1,441 @@
+/**
+ * RNGH's gesture states, as numbers, because its event payloads carry `state`
+ * and consumers compare it.
+ *
+ * Exported from the package entry as `State`, which is the name upstream uses
+ * — see ./index. The numbers are `react-native-gesture-handler` 3.1.0's own
+ * (`src/State.ts`) and a test pins every one of them, because a silently
+ * different number is the failure mode: `state === State.ACTIVE` would just
+ * quietly answer wrong.
+ */
+export declare const GESTURE_STATE: {
+    readonly UNDETERMINED: 0;
+    readonly FAILED: 1;
+    readonly BEGAN: 2;
+    readonly CANCELLED: 3;
+    readonly ACTIVE: 4;
+    readonly END: 5;
+};
+export type GestureStateValue = (typeof GESTURE_STATE)[keyof typeof GESTURE_STATE];
+/** RNGH's `TouchEventType`, for the `onTouches*` callbacks. */
+export declare const TOUCH_EVENT_TYPE: {
+    readonly UNDETERMINED: 0;
+    readonly TOUCHES_DOWN: 1;
+    readonly TOUCHES_MOVE: 2;
+    readonly TOUCHES_UP: 3;
+    readonly TOUCHES_CANCEL: 4;
+};
+export type TouchEventTypeValue = (typeof TOUCH_EVENT_TYPE)[keyof typeof TOUCH_EVENT_TYPE];
+/**
+ * RNGH's `PointerType`. Every event here is `MOUSE`: the responder system
+ * fabricates one touch per pointer and this platform has no touch input to
+ * distinguish it from (`docs/research/gestures.md` — wlroots offers no
+ * virtual-touch protocol, so there is nothing to test a `TOUCH` path with).
+ *
+ * `STYLUS` is the one exception and `ForceTouch` is why: a pressure reading
+ * only ever comes from a tablet tool, so the recognizer fed by
+ * `GtkGestureStylus` reports the pointer type that is actually true rather
+ * than the platform default.
+ */
+export declare const POINTER_TYPE: {
+    readonly TOUCH: 0;
+    readonly STYLUS: 1;
+    readonly MOUSE: 2;
+    readonly KEY: 3;
+    readonly OTHER: 4;
+};
+/**
+ * RNGH's `Directions`, which `Gesture.Fling().direction()` takes.
+ *
+ * A BITMASK, and that is the whole of its API: `Directions.LEFT |
+ * Directions.RIGHT` is a fling that accepts either. The four numbers are
+ * `react-native-gesture-handler` 3.1.0's own (`src/Directions.ts`) and a test
+ * pins them, for the same reason `State`'s six are pinned — a silently
+ * different bit would go on compiling and quietly accept the wrong direction.
+ */
+export declare const DIRECTIONS: {
+    readonly RIGHT: 1;
+    readonly LEFT: 2;
+    readonly UP: 4;
+    readonly DOWN: 8;
+};
+/**
+ * The four diagonals, which upstream keeps INTERNAL — they are not on the
+ * public `Directions` object and an app never names one.
+ *
+ * They are reachable all the same, and that is the point: a config of
+ * `UP | RIGHT` sets both bits, so `(UP_RIGHT & direction) === UP_RIGHT` holds
+ * and the diagonal is tested too, with a wider cone. Naming them here is what
+ * makes ./fling's alignment loop read like upstream's.
+ */
+export declare const DIAGONAL_DIRECTIONS: {
+    readonly UP_RIGHT: 5;
+    readonly DOWN_RIGHT: 9;
+    readonly UP_LEFT: 6;
+    readonly DOWN_LEFT: 10;
+};
+/**
+ * RNGH's `HoverEffect` — iOS's own pointer effects, and inert everywhere else
+ * including in upstream's web implementation.
+ *
+ * Exported as data rather than refused because it is data: `hoverEffect` is
+ * referenced by upstream's TYPES and by nothing in its web handler, so an app
+ * that sets it is writing correct portable code that happens to do nothing
+ * here. That is the same call `State` got, and the opposite of the one
+ * `RectButton` gets — a refusal is for something that would silently not
+ * work, not for a value that is honestly inert.
+ */
+export declare const HOVER_EFFECT: {
+    readonly NONE: 0;
+    readonly LIFT: 1;
+    readonly HIGHLIGHT: 2;
+};
+/**
+ * RNGH's `MouseButton`, a bitmask, exported as data for one narrow reason:
+ * `.mouseButton()` is already ACCEPTED here (and inert, as it is off Web
+ * upstream), so refusing the enum whose values it takes would make
+ * `.mouseButton(MouseButton.LEFT)` throw where `.mouseButton(1)` is fine.
+ * A knob and the constants it takes have to agree about whether they exist.
+ */
+export declare const MOUSE_BUTTON: {
+    readonly LEFT: 1;
+    readonly RIGHT: 2;
+    readonly MIDDLE: 4;
+    readonly BUTTON_4: 8;
+    readonly BUTTON_5: 16;
+    readonly ALL: 31;
+};
+/**
+ * An activation or failure bound.
+ *
+ * The single-number spelling is directional, and the direction is the SIGN:
+ * `activeOffsetX(20)` bounds the positive side only and leaves the negative
+ * side unbounded, `activeOffsetX(-20)` the other way round. Reading it as a
+ * symmetric ±20 turns a one-way drawer into a two-way one, silently.
+ */
+export type OffsetBound = number | readonly [number, number];
+/**
+ * Extra area in which a press still counts, in RNGH's gesture spelling rather
+ * than RN's View one — and note that it can SHRINK the area, which RN's
+ * cannot: a negative number pulls every edge inwards.
+ *
+ * `width`/`height` anchor the box to whichever side was named:
+ * `{ left: 0, width: 32 }` is "the leftmost 32px", which is exactly how
+ * `react-native-drawer-layout` catches an edge swipe on a closed drawer.
+ */
+export type GestureHitSlop = number | null | {
+    left?: number;
+    right?: number;
+    top?: number;
+    bottom?: number;
+    width?: number;
+    height?: number;
+    vertical?: number;
+    horizontal?: number;
+};
+/**
+ * One event payload, carrying the union of what both spellings read.
+ *
+ * The legacy spelling's `GestureUpdateEvent`/`GestureStateChangeEvent` and
+ * the hook spelling's `GestureEvent`/`GestureEndEvent` are subsets of this,
+ * so the recognizer builds it once and each facade hands it over as-is. The
+ * extra fields a given spelling does not document are harmless; inventing a
+ * second payload so each could be exactly minimal would be two things to keep
+ * correct instead of one.
+ */
+export type GestureEventPayload = {
+    handlerTag: number;
+    numberOfPointers: number;
+    pointerType: (typeof POINTER_TYPE)[keyof typeof POINTER_TYPE];
+    state: GestureStateValue;
+    /** Only meaningful on the state-change callbacks; the legacy spelling reads it. */
+    oldState: GestureStateValue;
+    /** Relative to the GESTURE's view, not to whatever widget carried the event. */
+    x: number;
+    y: number;
+    /** Window coordinates — RN's `pageX`/`pageY`. */
+    absoluteX: number;
+    absoluteY: number;
+    /** Measured from the point of ACTIVATION, not from the press. */
+    translationX: number;
+    translationY: number;
+    velocityX: number;
+    velocityY: number;
+    /** Delta of TRANSLATION since the previous update; equal to it on the first. */
+    changeX: number;
+    changeY: number;
+    /**
+     * `Pinch`: the scale relative to the start of the gesture, so 1 at the
+     * start and above 1 for a spread. Upstream's `PinchGestureHandlerEventPayload`
+     * field, with upstream's cumulative-and-multiplicative meaning. 1 for every
+     * other kind, which is the identity a consumer would multiply by anyway.
+     */
+    scale: number;
+    /**
+     * `Pinch`: the ratio between this update's `scale` and the previous one's —
+     * upstream's `scaleChange`, which is a RATIO where `changeX` is a
+     * difference, because scale composes by multiplication. On the first update
+     * it is the `scale` itself, exactly as upstream's `changeEventCalculator`
+     * returns `current.scale` when there is no previous event.
+     */
+    scaleChange: number;
+    /** `Pinch`: the gesture's focal point, in the gesture VIEW's coordinates. */
+    focalX: number;
+    focalY: number;
+    /**
+     * `Rotation`: radians since the start of the gesture, positive CLOCKWISE.
+     * Upstream's `RotationGestureHandlerEventPayload` field, same units and
+     * same sign. 0 for every other kind.
+     */
+    rotation: number;
+    /** `Rotation`: the difference in radians since the previous update. */
+    rotationChange: number;
+    /** `Rotation`: the point rotated about, in the gesture VIEW's coordinates. */
+    anchorX: number;
+    anchorY: number;
+    /**
+     * `Pinch`: scale change per SECOND. `Rotation`: radians per second.
+     *
+     * Upstream calls both of these `velocity` and documents both as per-second,
+     * and neither of its web implementations is: `PinchGestureHandler` divides
+     * by a millisecond `timeDelta` and never by 1000, and
+     * `RotationGestureDetector.timeDelta` returns `currentTime + previousTime`
+     * — an ADDITION, which makes the denominator roughly twice a page-lifetime
+     * timestamp and the result meaningless rather than merely mis-scaled.
+     * Android's `PinchGestureHandler` uses `timeDeltaSeconds` and agrees with
+     * the documentation.
+     *
+     * So there is no single upstream number to reproduce, and this is the same
+     * call `hitSlopRect` already makes about a plain-number `hitSlop`: where the
+     * web path contradicts both the documentation and upstream's own native
+     * path, follow the documentation and say so. Per second, in both.
+     */
+    velocity: number;
+    /**
+     * `ForceTouch`: the pressure, normalised to upstream's documented `[0, 1]`.
+     *
+     * 0 for every other kind, which is what an input with no pressure axis
+     * reports and therefore the only honest filler. See ./force-touch for where
+     * the number comes from and what it costs to produce one.
+     */
+    force: number;
+    /** `ForceTouch`: the difference since the previous update; the force itself on the first. */
+    forceChange: number;
+    /**
+     * Milliseconds since the press that started this gesture.
+     *
+     * Upstream carries it on `LongPress` alone, where it is the point of the
+     * gesture. It is filled in for every kind here for the same reason the rest
+     * of this payload is a union: one payload built once beats three that each
+     * have to stay correct, and a field a spelling does not document is
+     * harmless where a missing one is not.
+     */
+    duration: number;
+};
+/** The ending payload the hook spelling reads, which says `canceled` instead. */
+export type GestureEndEventPayload = GestureEventPayload & {
+    canceled: boolean;
+};
+/** One pointer, as the `onTouches*` callbacks see it. */
+export type GestureTouchData = {
+    id: number;
+    x: number;
+    y: number;
+    absoluteX: number;
+    absoluteY: number;
+};
+export type GestureTouchEvent = {
+    handlerTag: number;
+    numberOfTouches: number;
+    eventType: TouchEventTypeValue;
+    allTouches: GestureTouchData[];
+    changedTouches: GestureTouchData[];
+    state: GestureStateValue;
+    pointerType: (typeof POINTER_TYPE)[keyof typeof POINTER_TYPE];
+};
+/**
+ * The imperative handle handed to `onTouches*` by the legacy spelling.
+ *
+ * `activate()` from here is a second reason the responder system grew an
+ * out-of-event grant channel: a callback that decides mid-press to take the
+ * gesture is in exactly the position `activateAfterLongPress`'s timer is in.
+ */
+export type GestureStateManagerApi = {
+    begin: () => void;
+    activate: () => void;
+    fail: () => void;
+    end: () => void;
+};
+/**
+ * The internal callback set, in the hook spelling's names. Both facades
+ * normalise onto this; the recognizer knows no other names.
+ */
+export type RecognizerCallbacks = {
+    onBegin?: (event: GestureEventPayload) => void;
+    onActivate?: (event: GestureEventPayload) => void;
+    onUpdate?: (event: GestureEventPayload) => void;
+    onChange?: (event: GestureEventPayload) => void;
+    onDeactivate?: (event: GestureEventPayload, success: boolean) => void;
+    onFinalize?: (event: GestureEventPayload, success: boolean) => void;
+    onTouchesDown?: (event: GestureTouchEvent, manager: GestureStateManagerApi) => void;
+    onTouchesMove?: (event: GestureTouchEvent, manager: GestureStateManagerApi) => void;
+    onTouchesUp?: (event: GestureTouchEvent, manager: GestureStateManagerApi) => void;
+    onTouchesCancel?: (event: GestureTouchEvent, manager: GestureStateManagerApi) => void;
+};
+/**
+ * How one gesture names another in a relation.
+ *
+ * Upstream's `GestureRef`, in all three of its spellings: the other gesture
+ * itself, a ref built with `withRef()` holding it, or a raw handler tag. A
+ * composed gesture stands for every gesture inside it.
+ *
+ * The reference is deliberately not a tag: a tag identifies a MOUNTED
+ * gesture, and an app writes its relations against gesture objects it built
+ * itself, often before either end is mounted. ./relations resolves the two.
+ */
+export type GestureRef = AnyGestureSpec | {
+    current: unknown;
+} | number;
+/** The three relation maps, as one gesture's share of them. */
+export type GestureRelations = {
+    waitFor: readonly GestureRef[];
+    simultaneousHandlers: readonly GestureRef[];
+    blocksHandlers: readonly GestureRef[];
+};
+/** Everything every spelling of every kind configures, normalised. */
+export type RecognizerConfig = RecognizerCallbacks & {
+    waitFor?: readonly GestureRef[];
+    simultaneousHandlers?: readonly GestureRef[];
+    blocksHandlers?: readonly GestureRef[];
+    enabled?: boolean;
+    hitSlop?: GestureHitSlop;
+    shouldCancelWhenOutside?: boolean;
+    minPointers?: number;
+    maxPointers?: number;
+    /** Only the `onTouches*` state manager may activate the gesture. */
+    manualActivation?: boolean;
+    activeOffsetX?: OffsetBound;
+    activeOffsetY?: OffsetBound;
+    failOffsetX?: OffsetBound;
+    failOffsetY?: OffsetBound;
+    minDistance?: number;
+    minVelocity?: number;
+    minVelocityX?: number;
+    minVelocityY?: number;
+    activateAfterLongPress?: number;
+    /** Presses required before the tap activates. Upstream's default is 1. */
+    numberOfTaps?: number;
+    /** How fast the pointer must come back up. Upstream's default is 500ms. */
+    maxDuration?: number;
+    /** How long the next tap may take to arrive. Upstream's default is 500ms. */
+    maxDelay?: number;
+    maxDeltaX?: number;
+    maxDeltaY?: number;
+    /**
+     * Take the gesture the instant the pointer goes down, instead of waiting
+     * for the wrapped view to start handling it. Upstream's spelling for a
+     * native view that is a BUTTON rather than a scrollable.
+     */
+    shouldActivateOnStart?: boolean;
+    /**
+     * Upstream: an active `Native` handler that disallows interruption cannot
+     * be cancelled by anything else. Recorded and read by nothing yet — it is a
+     * statement about ARBITRATION, and the registry that arbitrates is the
+     * orchestrator's. Storing it is what lets that registry find it later;
+     * refusing it would refuse `@gorhom/bottom-sheet`'s own configuration for a
+     * knob whose only effect is on a relation it also sets explicitly.
+     */
+    disallowInterruption?: boolean;
+    /** Upstream's companion to `disallowInterruption`, same treatment. */
+    yieldsToContinuousGestures?: boolean;
+    /** How long the pointer must stay down. Upstream's default is 500ms. */
+    minDuration?: number;
+    /**
+     * Exactly this many pointers. Upstream's spelling for LongPress and for
+     * Fling, and EXACT in both: `Fling` compares it against the most pointers
+     * the interaction ever had at once, and refuses a mismatch either way.
+     */
+    numberOfPointers?: number;
+    /**
+     * A BITMASK of `Directions`, defaulting to `Directions.RIGHT`. Several
+     * directions are one value: `Directions.LEFT | Directions.RIGHT`.
+     */
+    direction?: number;
+    /**
+     * iOS's own pointer effect. Recorded and inert, exactly as it is inert in
+     * upstream's web implementation — nothing there branches on it either.
+     */
+    hoverEffect?: number;
+    /** Pressure below which the gesture will not activate. Upstream documents 0.2. */
+    minForce?: number;
+    /** Pressure above which the gesture FAILS. Unset means no ceiling. */
+    maxForce?: number;
+    /**
+     * Haptic feedback on activation. Recorded and inert: there is no haptic
+     * device on this platform and upstream implements it in iOS code only.
+     */
+    feedbackOnActivation?: boolean;
+    /**
+     * How far the pointer may travel and still count. Upstream defaults it to
+     * 10 for `LongPress` and leaves it UNSET for `Tap` — a tap that drags 200px
+     * inside the view and lifts in time is still a tap there, which reads like
+     * an oversight and is reproduced because guessing a default would silently
+     * refuse taps upstream accepts.
+     */
+    maxDistance?: number;
+    runOnJS?: boolean;
+    averageTouches?: boolean;
+    enableTrackpadTwoFingerGesture?: boolean;
+    cancelsTouchesInView?: boolean;
+    activeCursor?: string;
+    mouseButton?: number;
+    testId?: string;
+};
+/**
+ * Which predicates the shared machine runs. Spelled as upstream's
+ * `SingleGestureName` reads, minus the `GestureHandler` suffix.
+ */
+export type GestureKind = "pan" | "tap" | "longPress" | "native" | "pinch" | "rotation" | "fling" | "manual" | "hover" | "forceTouch";
+/**
+ * What a `GestureDetector` consumes. Both spellings produce exactly this.
+ *
+ * No `handlerTag`: a tag identifies a MOUNTED gesture, and both spellings
+ * rebuild their object on every render (upstream's do too — the builder is
+ * called in the component body, the hook returns a fresh config). The
+ * detector mints one stable tag for as long as it is mounted, which is the
+ * identity that means something.
+ */
+export type GestureSpec = {
+    readonly kind: GestureKind;
+    readonly config: RecognizerConfig;
+};
+/** Which of the three ways a group of gestures was put together. */
+export type ComposedGestureKind = "race" | "simultaneous" | "exclusive";
+/**
+ * What `Gesture.Race()`, `Gesture.Simultaneous()` and `Gesture.Exclusive()`
+ * produce — a LIST and a label, with no mechanism in it.
+ *
+ * The composers are list-builders over the three relation maps and nothing
+ * else: `Race` adds no relation at all because racing IS the default,
+ * `Simultaneous` is a pairwise fill of `simultaneousHandlers`, and
+ * `Exclusive` is a chain fill of `waitFor` where every group waits for all
+ * the groups before it. See ./composition, which is where that is spelled
+ * out, and note there is no third state and no second arbitration path.
+ */
+export type ComposedGestureSpec = {
+    readonly composed: ComposedGestureKind;
+    readonly gestures: readonly AnyGestureSpec[];
+    /** Upstream's flattening hook: every single gesture, composition removed. */
+    toGestureArray: () => GestureSpec[];
+};
+/** What a `GestureDetector` accepts: one gesture, or a composition of them. */
+export type AnyGestureSpec = GestureSpec | ComposedGestureSpec;
+/** RNGH's `handlerTag`: an identity for one mounted gesture. */
+export declare const mintHandlerTag: () => number;
+/** Whether a value is one recognizer rather than a composition of them. */
+export declare const isGestureSpec: (value: unknown) => value is GestureSpec;
+export declare const isComposedGestureSpec: (value: unknown) => value is ComposedGestureSpec;
+/** Whether a value is something a `GestureDetector` can drive. */
+export declare const isAnyGestureSpec: (value: unknown) => value is AnyGestureSpec;
+/** Every single gesture in a composition, in the order they were written. */
+export declare const flattenGestures: (gesture: AnyGestureSpec) => GestureSpec[];

package/dist/gesture-handler-compat/types.js

@@ -0,0 +1,167 @@
+// The internal shape of a gesture, and the vocabulary its callbacks speak.
+//
+// THIS is the implementation. `Gesture.Pan()` and `usePanGesture()` are two
+// spellings that both produce a `GestureSpec` and nothing else, which is the
+// one architectural decision this module is not free to get wrong: upstream
+// deprecated all twelve `Gesture.*` statics in 3.1.0 in favour of a hook tree
+// and had to rewrite the internals because the builder WAS the internals.
+//
+// One config type covers all three recognizers rather than one per kind, and
+// that is the same call: `Tap` and `LongPress` are the same state machine as
+// `Pan` with different predicates, so what tells them apart is which fields a
+// decider READS, not which fields exist. A per-kind config would have to be
+// narrowed at every point the machine touches it, for no behaviour.
+//
+// The two spellings are not cosmetic variants of each other, and that is the
+// reason this middle layer earns its keep. Upstream's hook renamed `onStart`
+// to `onActivate` and `onEnd` to `onDeactivate`, dropped `onChange`, renamed
+// `onTouchesCancelled` to `onTouchesCancel`, and replaced the
+// `(event, success)` ending signature with a `canceled` field on the event.
+// Neither naming is privileged here: the internal callbacks use the newer
+// names because that is the shape upstream is migrating towards, and both
+// public spellings adapt onto them.
+//
+// Config is plain data on purpose. A builder that accumulated behaviour
+// rather than values would make the hook spelling a reimplementation instead
+// of a second constructor, and would leave nothing for the orchestrator
+// (slice 3) to read.
+/**
+ * RNGH's gesture states, as numbers, because its event payloads carry `state`
+ * and consumers compare it.
+ *
+ * Exported from the package entry as `State`, which is the name upstream uses
+ * — see ./index. The numbers are `react-native-gesture-handler` 3.1.0's own
+ * (`src/State.ts`) and a test pins every one of them, because a silently
+ * different number is the failure mode: `state === State.ACTIVE` would just
+ * quietly answer wrong.
+ */
+export const GESTURE_STATE = {
+    UNDETERMINED: 0,
+    FAILED: 1,
+    BEGAN: 2,
+    CANCELLED: 3,
+    ACTIVE: 4,
+    END: 5,
+};
+/** RNGH's `TouchEventType`, for the `onTouches*` callbacks. */
+export const TOUCH_EVENT_TYPE = {
+    UNDETERMINED: 0,
+    TOUCHES_DOWN: 1,
+    TOUCHES_MOVE: 2,
+    TOUCHES_UP: 3,
+    TOUCHES_CANCEL: 4,
+};
+/**
+ * RNGH's `PointerType`. Every event here is `MOUSE`: the responder system
+ * fabricates one touch per pointer and this platform has no touch input to
+ * distinguish it from (`docs/research/gestures.md` — wlroots offers no
+ * virtual-touch protocol, so there is nothing to test a `TOUCH` path with).
+ *
+ * `STYLUS` is the one exception and `ForceTouch` is why: a pressure reading
+ * only ever comes from a tablet tool, so the recognizer fed by
+ * `GtkGestureStylus` reports the pointer type that is actually true rather
+ * than the platform default.
+ */
+export const POINTER_TYPE = {
+    TOUCH: 0,
+    STYLUS: 1,
+    MOUSE: 2,
+    KEY: 3,
+    OTHER: 4,
+};
+/**
+ * RNGH's `Directions`, which `Gesture.Fling().direction()` takes.
+ *
+ * A BITMASK, and that is the whole of its API: `Directions.LEFT |
+ * Directions.RIGHT` is a fling that accepts either. The four numbers are
+ * `react-native-gesture-handler` 3.1.0's own (`src/Directions.ts`) and a test
+ * pins them, for the same reason `State`'s six are pinned — a silently
+ * different bit would go on compiling and quietly accept the wrong direction.
+ */
+export const DIRECTIONS = {
+    RIGHT: 1,
+    LEFT: 2,
+    UP: 4,
+    DOWN: 8,
+};
+/**
+ * The four diagonals, which upstream keeps INTERNAL — they are not on the
+ * public `Directions` object and an app never names one.
+ *
+ * They are reachable all the same, and that is the point: a config of
+ * `UP | RIGHT` sets both bits, so `(UP_RIGHT & direction) === UP_RIGHT` holds
+ * and the diagonal is tested too, with a wider cone. Naming them here is what
+ * makes ./fling's alignment loop read like upstream's.
+ */
+export const DIAGONAL_DIRECTIONS = {
+    UP_RIGHT: 5,
+    DOWN_RIGHT: 9,
+    UP_LEFT: 6,
+    DOWN_LEFT: 10,
+};
+/**
+ * RNGH's `HoverEffect` — iOS's own pointer effects, and inert everywhere else
+ * including in upstream's web implementation.
+ *
+ * Exported as data rather than refused because it is data: `hoverEffect` is
+ * referenced by upstream's TYPES and by nothing in its web handler, so an app
+ * that sets it is writing correct portable code that happens to do nothing
+ * here. That is the same call `State` got, and the opposite of the one
+ * `RectButton` gets — a refusal is for something that would silently not
+ * work, not for a value that is honestly inert.
+ */
+export const HOVER_EFFECT = {
+    NONE: 0,
+    LIFT: 1,
+    HIGHLIGHT: 2,
+};
+/**
+ * RNGH's `MouseButton`, a bitmask, exported as data for one narrow reason:
+ * `.mouseButton()` is already ACCEPTED here (and inert, as it is off Web
+ * upstream), so refusing the enum whose values it takes would make
+ * `.mouseButton(MouseButton.LEFT)` throw where `.mouseButton(1)` is fine.
+ * A knob and the constants it takes have to agree about whether they exist.
+ */
+export const MOUSE_BUTTON = {
+    LEFT: 1,
+    RIGHT: 2,
+    MIDDLE: 4,
+    BUTTON_4: 8,
+    BUTTON_5: 16,
+    ALL: 31,
+};
+const KINDS = new Set([
+    "pan",
+    "tap",
+    "longPress",
+    "native",
+    "pinch",
+    "rotation",
+    "fling",
+    "manual",
+    "hover",
+    "forceTouch",
+]);
+let nextHandlerTag = 1;
+/** RNGH's `handlerTag`: an identity for one mounted gesture. */
+export const mintHandlerTag = () => {
+    const tag = nextHandlerTag;
+    nextHandlerTag += 1;
+    return tag;
+};
+/** Whether a value is one recognizer rather than a composition of them. */
+export const isGestureSpec = (value) => typeof value === "object" &&
+    value !== null &&
+    KINDS.has(value.kind) &&
+    typeof value.config === "object";
+export const isComposedGestureSpec = (value) => typeof value === "object" &&
+    value !== null &&
+    Array.isArray(value.gestures) &&
+    typeof value.composed === "string";
+/** Whether a value is something a `GestureDetector` can drive. */
+export const isAnyGestureSpec = (value) => isGestureSpec(value) || isComposedGestureSpec(value);
+/** Every single gesture in a composition, in the order they were written. */
+export const flattenGestures = (gesture) => isComposedGestureSpec(gesture)
+    ? gesture.gestures.flatMap(flattenGestures)
+    : [gesture];
+//# sourceMappingURL=types.js.map

package/dist/gesture-handler-compat/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/gesture-handler-compat/types.ts"],"names":[],"mappings":"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","sourcesContent":["// The internal shape of a gesture, and the vocabulary its callbacks speak.\n//\n// THIS is the implementation. `Gesture.Pan()` and `usePanGesture()` are two\n// spellings that both produce a `GestureSpec` and nothing else, which is the\n// one architectural decision this module is not free to get wrong: upstream\n// deprecated all twelve `Gesture.*` statics in 3.1.0 in favour of a hook tree\n// and had to rewrite the internals because the builder WAS the internals.\n//\n// One config type covers all three recognizers rather than one per kind, and\n// that is the same call: `Tap` and `LongPress` are the same state machine as\n// `Pan` with different predicates, so what tells them apart is which fields a\n// decider READS, not which fields exist. A per-kind config would have to be\n// narrowed at every point the machine touches it, for no behaviour.\n//\n// The two spellings are not cosmetic variants of each other, and that is the\n// reason this middle layer earns its keep. Upstream's hook renamed `onStart`\n// to `onActivate` and `onEnd` to `onDeactivate`, dropped `onChange`, renamed\n// `onTouchesCancelled` to `onTouchesCancel`, and replaced the\n// `(event, success)` ending signature with a `canceled` field on the event.\n// Neither naming is privileged here: the internal callbacks use the newer\n// names because that is the shape upstream is migrating towards, and both\n// public spellings adapt onto them.\n//\n// Config is plain data on purpose. A builder that accumulated behaviour\n// rather than values would make the hook spelling a reimplementation instead\n// of a second constructor, and would leave nothing for the orchestrator\n// (slice 3) to read.\n\n/**\n * RNGH's gesture states, as numbers, because its event payloads carry `state`\n * and consumers compare it.\n *\n * Exported from the package entry as `State`, which is the name upstream uses\n * — see ./index. The numbers are `react-native-gesture-handler` 3.1.0's own\n * (`src/State.ts`) and a test pins every one of them, because a silently\n * different number is the failure mode: `state === State.ACTIVE` would just\n * quietly answer wrong.\n */\nexport const GESTURE_STATE = {\n  UNDETERMINED: 0,\n  FAILED: 1,\n  BEGAN: 2,\n  CANCELLED: 3,\n  ACTIVE: 4,\n  END: 5,\n} as const\n\nexport type GestureStateValue =\n  (typeof GESTURE_STATE)[keyof typeof GESTURE_STATE]\n\n/** RNGH's `TouchEventType`, for the `onTouches*` callbacks. */\nexport const TOUCH_EVENT_TYPE = {\n  UNDETERMINED: 0,\n  TOUCHES_DOWN: 1,\n  TOUCHES_MOVE: 2,\n  TOUCHES_UP: 3,\n  TOUCHES_CANCEL: 4,\n} as const\n\nexport type TouchEventTypeValue =\n  (typeof TOUCH_EVENT_TYPE)[keyof typeof TOUCH_EVENT_TYPE]\n\n/**\n * RNGH's `PointerType`. Every event here is `MOUSE`: the responder system\n * fabricates one touch per pointer and this platform has no touch input to\n * distinguish it from (`docs/research/gestures.md` — wlroots offers no\n * virtual-touch protocol, so there is nothing to test a `TOUCH` path with).\n *\n * `STYLUS` is the one exception and `ForceTouch` is why: a pressure reading\n * only ever comes from a tablet tool, so the recognizer fed by\n * `GtkGestureStylus` reports the pointer type that is actually true rather\n * than the platform default.\n */\nexport const POINTER_TYPE = {\n  TOUCH: 0,\n  STYLUS: 1,\n  MOUSE: 2,\n  KEY: 3,\n  OTHER: 4,\n} as const\n\n/**\n * RNGH's `Directions`, which `Gesture.Fling().direction()` takes.\n *\n * A BITMASK, and that is the whole of its API: `Directions.LEFT |\n * Directions.RIGHT` is a fling that accepts either. The four numbers are\n * `react-native-gesture-handler` 3.1.0's own (`src/Directions.ts`) and a test\n * pins them, for the same reason `State`'s six are pinned — a silently\n * different bit would go on compiling and quietly accept the wrong direction.\n */\nexport const DIRECTIONS = {\n  RIGHT: 1,\n  LEFT: 2,\n  UP: 4,\n  DOWN: 8,\n} as const\n\n/**\n * The four diagonals, which upstream keeps INTERNAL — they are not on the\n * public `Directions` object and an app never names one.\n *\n * They are reachable all the same, and that is the point: a config of\n * `UP | RIGHT` sets both bits, so `(UP_RIGHT & direction) === UP_RIGHT` holds\n * and the diagonal is tested too, with a wider cone. Naming them here is what\n * makes ./fling's alignment loop read like upstream's.\n */\nexport const DIAGONAL_DIRECTIONS = {\n  UP_RIGHT: 5,\n  DOWN_RIGHT: 9,\n  UP_LEFT: 6,\n  DOWN_LEFT: 10,\n} as const\n\n/**\n * RNGH's `HoverEffect` — iOS's own pointer effects, and inert everywhere else\n * including in upstream's web implementation.\n *\n * Exported as data rather than refused because it is data: `hoverEffect` is\n * referenced by upstream's TYPES and by nothing in its web handler, so an app\n * that sets it is writing correct portable code that happens to do nothing\n * here. That is the same call `State` got, and the opposite of the one\n * `RectButton` gets — a refusal is for something that would silently not\n * work, not for a value that is honestly inert.\n */\nexport const HOVER_EFFECT = {\n  NONE: 0,\n  LIFT: 1,\n  HIGHLIGHT: 2,\n} as const\n\n/**\n * RNGH's `MouseButton`, a bitmask, exported as data for one narrow reason:\n * `.mouseButton()` is already ACCEPTED here (and inert, as it is off Web\n * upstream), so refusing the enum whose values it takes would make\n * `.mouseButton(MouseButton.LEFT)` throw where `.mouseButton(1)` is fine.\n * A knob and the constants it takes have to agree about whether they exist.\n */\nexport const MOUSE_BUTTON = {\n  LEFT: 1,\n  RIGHT: 2,\n  MIDDLE: 4,\n  BUTTON_4: 8,\n  BUTTON_5: 16,\n  ALL: 31,\n} as const\n\n/**\n * An activation or failure bound.\n *\n * The single-number spelling is directional, and the direction is the SIGN:\n * `activeOffsetX(20)` bounds the positive side only and leaves the negative\n * side unbounded, `activeOffsetX(-20)` the other way round. Reading it as a\n * symmetric ±20 turns a one-way drawer into a two-way one, silently.\n */\nexport type OffsetBound = number | readonly [number, number]\n\n/**\n * Extra area in which a press still counts, in RNGH's gesture spelling rather\n * than RN's View one — and note that it can SHRINK the area, which RN's\n * cannot: a negative number pulls every edge inwards.\n *\n * `width`/`height` anchor the box to whichever side was named:\n * `{ left: 0, width: 32 }` is \"the leftmost 32px\", which is exactly how\n * `react-native-drawer-layout` catches an edge swipe on a closed drawer.\n */\nexport type GestureHitSlop =\n  | number\n  | null\n  | {\n      left?: number\n      right?: number\n      top?: number\n      bottom?: number\n      width?: number\n      height?: number\n      vertical?: number\n      horizontal?: number\n    }\n\n/**\n * One event payload, carrying the union of what both spellings read.\n *\n * The legacy spelling's `GestureUpdateEvent`/`GestureStateChangeEvent` and\n * the hook spelling's `GestureEvent`/`GestureEndEvent` are subsets of this,\n * so the recognizer builds it once and each facade hands it over as-is. The\n * extra fields a given spelling does not document are harmless; inventing a\n * second payload so each could be exactly minimal would be two things to keep\n * correct instead of one.\n */\nexport type GestureEventPayload = {\n  handlerTag: number\n  numberOfPointers: number\n  pointerType: (typeof POINTER_TYPE)[keyof typeof POINTER_TYPE]\n  state: GestureStateValue\n  /** Only meaningful on the state-change callbacks; the legacy spelling reads it. */\n  oldState: GestureStateValue\n  /** Relative to the GESTURE's view, not to whatever widget carried the event. */\n  x: number\n  y: number\n  /** Window coordinates — RN's `pageX`/`pageY`. */\n  absoluteX: number\n  absoluteY: number\n  /** Measured from the point of ACTIVATION, not from the press. */\n  translationX: number\n  translationY: number\n  velocityX: number\n  velocityY: number\n  /** Delta of TRANSLATION since the previous update; equal to it on the first. */\n  changeX: number\n  changeY: number\n  /**\n   * `Pinch`: the scale relative to the start of the gesture, so 1 at the\n   * start and above 1 for a spread. Upstream's `PinchGestureHandlerEventPayload`\n   * field, with upstream's cumulative-and-multiplicative meaning. 1 for every\n   * other kind, which is the identity a consumer would multiply by anyway.\n   */\n  scale: number\n  /**\n   * `Pinch`: the ratio between this update's `scale` and the previous one's —\n   * upstream's `scaleChange`, which is a RATIO where `changeX` is a\n   * difference, because scale composes by multiplication. On the first update\n   * it is the `scale` itself, exactly as upstream's `changeEventCalculator`\n   * returns `current.scale` when there is no previous event.\n   */\n  scaleChange: number\n  /** `Pinch`: the gesture's focal point, in the gesture VIEW's coordinates. */\n  focalX: number\n  focalY: number\n  /**\n   * `Rotation`: radians since the start of the gesture, positive CLOCKWISE.\n   * Upstream's `RotationGestureHandlerEventPayload` field, same units and\n   * same sign. 0 for every other kind.\n   */\n  rotation: number\n  /** `Rotation`: the difference in radians since the previous update. */\n  rotationChange: number\n  /** `Rotation`: the point rotated about, in the gesture VIEW's coordinates. */\n  anchorX: number\n  anchorY: number\n  /**\n   * `Pinch`: scale change per SECOND. `Rotation`: radians per second.\n   *\n   * Upstream calls both of these `velocity` and documents both as per-second,\n   * and neither of its web implementations is: `PinchGestureHandler` divides\n   * by a millisecond `timeDelta` and never by 1000, and\n   * `RotationGestureDetector.timeDelta` returns `currentTime + previousTime`\n   * — an ADDITION, which makes the denominator roughly twice a page-lifetime\n   * timestamp and the result meaningless rather than merely mis-scaled.\n   * Android's `PinchGestureHandler` uses `timeDeltaSeconds` and agrees with\n   * the documentation.\n   *\n   * So there is no single upstream number to reproduce, and this is the same\n   * call `hitSlopRect` already makes about a plain-number `hitSlop`: where the\n   * web path contradicts both the documentation and upstream's own native\n   * path, follow the documentation and say so. Per second, in both.\n   */\n  velocity: number\n  /**\n   * `ForceTouch`: the pressure, normalised to upstream's documented `[0, 1]`.\n   *\n   * 0 for every other kind, which is what an input with no pressure axis\n   * reports and therefore the only honest filler. See ./force-touch for where\n   * the number comes from and what it costs to produce one.\n   */\n  force: number\n  /** `ForceTouch`: the difference since the previous update; the force itself on the first. */\n  forceChange: number\n  /**\n   * Milliseconds since the press that started this gesture.\n   *\n   * Upstream carries it on `LongPress` alone, where it is the point of the\n   * gesture. It is filled in for every kind here for the same reason the rest\n   * of this payload is a union: one payload built once beats three that each\n   * have to stay correct, and a field a spelling does not document is\n   * harmless where a missing one is not.\n   */\n  duration: number\n}\n\n/** The ending payload the hook spelling reads, which says `canceled` instead. */\nexport type GestureEndEventPayload = GestureEventPayload & { canceled: boolean }\n\n/** One pointer, as the `onTouches*` callbacks see it. */\nexport type GestureTouchData = {\n  id: number\n  x: number\n  y: number\n  absoluteX: number\n  absoluteY: number\n}\n\nexport type GestureTouchEvent = {\n  handlerTag: number\n  numberOfTouches: number\n  eventType: TouchEventTypeValue\n  allTouches: GestureTouchData[]\n  changedTouches: GestureTouchData[]\n  state: GestureStateValue\n  pointerType: (typeof POINTER_TYPE)[keyof typeof POINTER_TYPE]\n}\n\n/**\n * The imperative handle handed to `onTouches*` by the legacy spelling.\n *\n * `activate()` from here is a second reason the responder system grew an\n * out-of-event grant channel: a callback that decides mid-press to take the\n * gesture is in exactly the position `activateAfterLongPress`'s timer is in.\n */\nexport type GestureStateManagerApi = {\n  begin: () => void\n  activate: () => void\n  fail: () => void\n  end: () => void\n}\n\n/**\n * The internal callback set, in the hook spelling's names. Both facades\n * normalise onto this; the recognizer knows no other names.\n */\nexport type RecognizerCallbacks = {\n  onBegin?: (event: GestureEventPayload) => void\n  onActivate?: (event: GestureEventPayload) => void\n  onUpdate?: (event: GestureEventPayload) => void\n  onChange?: (event: GestureEventPayload) => void\n  onDeactivate?: (event: GestureEventPayload, success: boolean) => void\n  onFinalize?: (event: GestureEventPayload, success: boolean) => void\n  onTouchesDown?: (\n    event: GestureTouchEvent,\n    manager: GestureStateManagerApi,\n  ) => void\n  onTouchesMove?: (\n    event: GestureTouchEvent,\n    manager: GestureStateManagerApi,\n  ) => void\n  onTouchesUp?: (\n    event: GestureTouchEvent,\n    manager: GestureStateManagerApi,\n  ) => void\n  onTouchesCancel?: (\n    event: GestureTouchEvent,\n    manager: GestureStateManagerApi,\n  ) => void\n}\n\n/**\n * How one gesture names another in a relation.\n *\n * Upstream's `GestureRef`, in all three of its spellings: the other gesture\n * itself, a ref built with `withRef()` holding it, or a raw handler tag. A\n * composed gesture stands for every gesture inside it.\n *\n * The reference is deliberately not a tag: a tag identifies a MOUNTED\n * gesture, and an app writes its relations against gesture objects it built\n * itself, often before either end is mounted. ./relations resolves the two.\n */\nexport type GestureRef = AnyGestureSpec | { current: unknown } | number\n\n/** The three relation maps, as one gesture's share of them. */\nexport type GestureRelations = {\n  waitFor: readonly GestureRef[]\n  simultaneousHandlers: readonly GestureRef[]\n  blocksHandlers: readonly GestureRef[]\n}\n\n/** Everything every spelling of every kind configures, normalised. */\nexport type RecognizerConfig = RecognizerCallbacks & {\n  // --- the relations, in the names the three maps carry ---\n  //\n  // Config rather than behaviour, like everything else here: both spellings\n  // write these lists and the orchestrator reads them. `waitFor` is\n  // `requireExternalGestureToFail`, `simultaneousHandlers` is\n  // `simultaneousWithExternalGesture`, `blocksHandlers` is\n  // `blocksExternalGesture` — and `Exclusive` and `Simultaneous` fill the\n  // first two without adding a mechanism of their own.\n  waitFor?: readonly GestureRef[]\n  simultaneousHandlers?: readonly GestureRef[]\n  blocksHandlers?: readonly GestureRef[]\n\n  // --- common to all three kinds ---\n  enabled?: boolean\n  hitSlop?: GestureHitSlop\n  shouldCancelWhenOutside?: boolean\n  minPointers?: number\n  maxPointers?: number\n  /** Only the `onTouches*` state manager may activate the gesture. */\n  manualActivation?: boolean\n\n  // --- Pan ---\n  activeOffsetX?: OffsetBound\n  activeOffsetY?: OffsetBound\n  failOffsetX?: OffsetBound\n  failOffsetY?: OffsetBound\n  minDistance?: number\n  minVelocity?: number\n  minVelocityX?: number\n  minVelocityY?: number\n  activateAfterLongPress?: number\n\n  // --- Tap ---\n  /** Presses required before the tap activates. Upstream's default is 1. */\n  numberOfTaps?: number\n  /** How fast the pointer must come back up. Upstream's default is 500ms. */\n  maxDuration?: number\n  /** How long the next tap may take to arrive. Upstream's default is 500ms. */\n  maxDelay?: number\n  maxDeltaX?: number\n  maxDeltaY?: number\n\n  // --- Native ---\n  /**\n   * Take the gesture the instant the pointer goes down, instead of waiting\n   * for the wrapped view to start handling it. Upstream's spelling for a\n   * native view that is a BUTTON rather than a scrollable.\n   */\n  shouldActivateOnStart?: boolean\n  /**\n   * Upstream: an active `Native` handler that disallows interruption cannot\n   * be cancelled by anything else. Recorded and read by nothing yet — it is a\n   * statement about ARBITRATION, and the registry that arbitrates is the\n   * orchestrator's. Storing it is what lets that registry find it later;\n   * refusing it would refuse `@gorhom/bottom-sheet`'s own configuration for a\n   * knob whose only effect is on a relation it also sets explicitly.\n   */\n  disallowInterruption?: boolean\n  /** Upstream's companion to `disallowInterruption`, same treatment. */\n  yieldsToContinuousGestures?: boolean\n\n  // --- LongPress, and Fling, which spells it the same way ---\n  /** How long the pointer must stay down. Upstream's default is 500ms. */\n  minDuration?: number\n  /**\n   * Exactly this many pointers. Upstream's spelling for LongPress and for\n   * Fling, and EXACT in both: `Fling` compares it against the most pointers\n   * the interaction ever had at once, and refuses a mismatch either way.\n   */\n  numberOfPointers?: number\n\n  // --- Fling ---\n  /**\n   * A BITMASK of `Directions`, defaulting to `Directions.RIGHT`. Several\n   * directions are one value: `Directions.LEFT | Directions.RIGHT`.\n   */\n  direction?: number\n\n  // --- Hover ---\n  /**\n   * iOS's own pointer effect. Recorded and inert, exactly as it is inert in\n   * upstream's web implementation — nothing there branches on it either.\n   */\n  hoverEffect?: number\n\n  // --- ForceTouch ---\n  /** Pressure below which the gesture will not activate. Upstream documents 0.2. */\n  minForce?: number\n  /** Pressure above which the gesture FAILS. Unset means no ceiling. */\n  maxForce?: number\n  /**\n   * Haptic feedback on activation. Recorded and inert: there is no haptic\n   * device on this platform and upstream implements it in iOS code only.\n   */\n  feedbackOnActivation?: boolean\n\n  // --- Tap and LongPress share this one, with different defaults ---\n  /**\n   * How far the pointer may travel and still count. Upstream defaults it to\n   * 10 for `LongPress` and leaves it UNSET for `Tap` — a tap that drags 200px\n   * inside the view and lifts in time is still a tap there, which reads like\n   * an oversight and is reproduced because guessing a default would silently\n   * refuse taps upstream accepts.\n   */\n  maxDistance?: number\n\n  // Recorded, and deliberately not acted on. Each is either platform-specific\n  // upstream and inert off its platform (`averageTouches` is Android-only,\n  // `enableTrackpadTwoFingerGesture` and `cancelsTouchesInView` iOS-only,\n  // `activeCursor` and `mouseButton` Web-only) or asks for something this\n  // platform already gives it (`runOnJS` — there is one runtime here, so every\n  // callback already runs on the JS one). Keeping them in the config means it\n  // describes what the app asked for rather than only what was honoured.\n  runOnJS?: boolean\n  averageTouches?: boolean\n  enableTrackpadTwoFingerGesture?: boolean\n  cancelsTouchesInView?: boolean\n  activeCursor?: string\n  mouseButton?: number\n  testId?: string\n}\n\n/**\n * Which predicates the shared machine runs. Spelled as upstream's\n * `SingleGestureName` reads, minus the `GestureHandler` suffix.\n */\nexport type GestureKind =\n  | \"pan\"\n  | \"tap\"\n  | \"longPress\"\n  | \"native\"\n  | \"pinch\"\n  | \"rotation\"\n  | \"fling\"\n  | \"manual\"\n  | \"hover\"\n  | \"forceTouch\"\n\nconst KINDS = new Set<string>([\n  \"pan\",\n  \"tap\",\n  \"longPress\",\n  \"native\",\n  \"pinch\",\n  \"rotation\",\n  \"fling\",\n  \"manual\",\n  \"hover\",\n  \"forceTouch\",\n])\n\n/**\n * What a `GestureDetector` consumes. Both spellings produce exactly this.\n *\n * No `handlerTag`: a tag identifies a MOUNTED gesture, and both spellings\n * rebuild their object on every render (upstream's do too — the builder is\n * called in the component body, the hook returns a fresh config). The\n * detector mints one stable tag for as long as it is mounted, which is the\n * identity that means something.\n */\nexport type GestureSpec = {\n  readonly kind: GestureKind\n  readonly config: RecognizerConfig\n}\n\n/** Which of the three ways a group of gestures was put together. */\nexport type ComposedGestureKind = \"race\" | \"simultaneous\" | \"exclusive\"\n\n/**\n * What `Gesture.Race()`, `Gesture.Simultaneous()` and `Gesture.Exclusive()`\n * produce — a LIST and a label, with no mechanism in it.\n *\n * The composers are list-builders over the three relation maps and nothing\n * else: `Race` adds no relation at all because racing IS the default,\n * `Simultaneous` is a pairwise fill of `simultaneousHandlers`, and\n * `Exclusive` is a chain fill of `waitFor` where every group waits for all\n * the groups before it. See ./composition, which is where that is spelled\n * out, and note there is no third state and no second arbitration path.\n */\nexport type ComposedGestureSpec = {\n  readonly composed: ComposedGestureKind\n  readonly gestures: readonly AnyGestureSpec[]\n  /** Upstream's flattening hook: every single gesture, composition removed. */\n  toGestureArray: () => GestureSpec[]\n}\n\n/** What a `GestureDetector` accepts: one gesture, or a composition of them. */\nexport type AnyGestureSpec = GestureSpec | ComposedGestureSpec\n\nlet nextHandlerTag = 1\n\n/** RNGH's `handlerTag`: an identity for one mounted gesture. */\nexport const mintHandlerTag = (): number => {\n  const tag = nextHandlerTag\n  nextHandlerTag += 1\n  return tag\n}\n\n/** Whether a value is one recognizer rather than a composition of them. */\nexport const isGestureSpec = (value: unknown): value is GestureSpec =>\n  typeof value === \"object\" &&\n  value !== null &&\n  KINDS.has((value as GestureSpec).kind) &&\n  typeof (value as GestureSpec).config === \"object\"\n\nexport const isComposedGestureSpec = (\n  value: unknown,\n): value is ComposedGestureSpec =>\n  typeof value === \"object\" &&\n  value !== null &&\n  Array.isArray((value as ComposedGestureSpec).gestures) &&\n  typeof (value as ComposedGestureSpec).composed === \"string\"\n\n/** Whether a value is something a `GestureDetector` can drive. */\nexport const isAnyGestureSpec = (value: unknown): value is AnyGestureSpec =>\n  isGestureSpec(value) || isComposedGestureSpec(value)\n\n/** Every single gesture in a composition, in the order they were written. */\nexport const flattenGestures = (gesture: AnyGestureSpec): GestureSpec[] =>\n  isComposedGestureSpec(gesture)\n    ? gesture.gestures.flatMap(flattenGestures)\n    : [gesture]\n"]}