@satinhq/kit 0.0.0-stage → 0.1.0-beta.0

package/dist/gestures/arena.js

@@ -0,0 +1,417 @@
+const DEFER = Object.freeze({ disposition: 'defer' });
+export function deferGesture() {
+    return DEFER;
+}
+export function recognizeGesture(reason) {
+    return reason ? { disposition: 'recognize', reason } : { disposition: 'recognize' };
+}
+export function failGesture(reason) {
+    return reason ? { disposition: 'fail', reason } : { disposition: 'fail' };
+}
+function contains(region, point, bounds) {
+    if (region.kind === 'all')
+        return true;
+    if (region.kind === 'rect') {
+        return (point.x >= region.left &&
+            point.x <= region.right &&
+            point.y >= region.top &&
+            point.y <= region.bottom);
+    }
+    switch (region.edge) {
+        case 'bottom':
+            return point.y >= bounds.bottom - region.size && point.y <= bounds.bottom;
+        case 'left':
+            return point.x >= bounds.left && point.x <= bounds.left + region.size;
+        case 'right':
+            return point.x >= bounds.right - region.size && point.x <= bounds.right;
+        case 'top':
+            return point.y >= bounds.top && point.y <= bounds.top + region.size;
+    }
+}
+function assertDistance(name, value) {
+    if (value !== undefined && (!Number.isFinite(value) || value < 0)) {
+        throw new Error(`Satin gesture arena ${name} must be a finite non-negative number.`);
+    }
+}
+function validateDefinition(definition) {
+    const ids = new Set();
+    for (const recognizer of definition.recognizers) {
+        if (!recognizer.id) {
+            throw new Error('Satin gesture arena recognizer ids must not be empty.');
+        }
+        if (ids.has(recognizer.id)) {
+            throw new Error(`Satin gesture arena recognizer "${recognizer.id}" is duplicated.`);
+        }
+        if (!Number.isFinite(recognizer.priority)) {
+            throw new Error(`Satin gesture arena priority for "${recognizer.id}" must be finite.`);
+        }
+        if ((recognizer.participation ?? 'javascript') === 'javascript' && !recognizer.evaluate) {
+            throw new Error(`Satin gesture arena JavaScript recognizer "${recognizer.id}" needs an evaluator.`);
+        }
+        assertDistance('claimDistance', recognizer.hysteresis.claimDistance);
+        assertDistance('activationDistance', recognizer.hysteresis.activationDistance);
+        assertDistance('retentionDistance', recognizer.hysteresis.retentionDistance);
+        ids.add(recognizer.id);
+    }
+    const byId = new Map(definition.recognizers.map(recognizer => [recognizer.id, recognizer]));
+    for (const recognizer of definition.recognizers) {
+        for (const requirement of recognizer.requiresFailureOf ?? []) {
+            if (!byId.has(requirement)) {
+                throw new Error(`Satin gesture arena recognizer "${recognizer.id}" requires unknown recognizer "${requirement}" to fail.`);
+            }
+            if (requirement === recognizer.id) {
+                throw new Error(`Satin gesture arena recognizer "${recognizer.id}" cannot require itself to fail.`);
+            }
+        }
+        for (const simultaneousId of recognizer.simultaneousWith ?? []) {
+            const peer = byId.get(simultaneousId);
+            if (!peer) {
+                throw new Error(`Satin gesture arena recognizer "${recognizer.id}" names unknown simultaneous recognizer "${simultaneousId}".`);
+            }
+            if (!(peer.simultaneousWith ?? []).includes(recognizer.id)) {
+                throw new Error(`Satin gesture arena simultaneity must be mutual between "${recognizer.id}" and "${simultaneousId}".`);
+            }
+        }
+    }
+    const visiting = new Set();
+    const visited = new Set();
+    const visit = (id) => {
+        if (visiting.has(id)) {
+            throw new Error(`Satin gesture arena failure requirements contain a cycle at "${id}".`);
+        }
+        if (visited.has(id))
+            return;
+        visiting.add(id);
+        for (const dependency of byId.get(id)?.requiresFailureOf ?? [])
+            visit(dependency);
+        visiting.delete(id);
+        visited.add(id);
+    };
+    for (const recognizer of definition.recognizers)
+        visit(recognizer.id);
+    for (const exclusion of definition.exclusions ?? []) {
+        if (exclusion.recognizerIds === 'all')
+            continue;
+        for (const recognizerId of exclusion.recognizerIds) {
+            if (!ids.has(recognizerId)) {
+                throw new Error(`Satin gesture arena exclusion "${exclusion.id}" names unknown recognizer "${recognizerId}".`);
+            }
+        }
+    }
+}
+export function createGestureArena(definition) {
+    validateDefinition(definition);
+    return Object.freeze({
+        bounds: Object.freeze({ ...definition.bounds }),
+        exclusions: Object.freeze([...(definition.exclusions ?? [])]),
+        recognizers: Object.freeze([...definition.recognizers]),
+    });
+}
+function cloneRecognizers(session) {
+    return Object.fromEntries(Object.entries(session.recognizers).map(([id, snapshot]) => [id, { ...snapshot }]));
+}
+function snapshotSession(session, recognizers, changes = {}) {
+    return Object.freeze({
+        ...session,
+        ...changes,
+        activePointerIds: Object.freeze([...(changes.activePointerIds ?? session.activePointerIds)]),
+        current: Object.freeze({ ...(changes.current ?? session.current) }),
+        recognizers: Object.freeze(Object.fromEntries(Object.entries(recognizers).map(([id, snapshot]) => [id, Object.freeze({ ...snapshot })]))),
+    });
+}
+function transition(reduction, recognizerId, to, reason) {
+    const snapshot = reduction.recognizers[recognizerId];
+    if (!snapshot || snapshot.state === to)
+        return;
+    const from = snapshot.state;
+    snapshot.state = to;
+    snapshot.ready = false;
+    snapshot.readyReason = undefined;
+    reduction.transitions.push({ from, reason, recognizerId, to });
+    if (snapshot.previewActive && to !== 'possible' && to !== 'began') {
+        snapshot.previewActive = false;
+        reduction.previews.push({ active: false, recognizerId });
+    }
+}
+function isExcluded(definition, recognizerId, point) {
+    return (definition.exclusions ?? []).find(exclusion => {
+        const applies = exclusion.recognizerIds === 'all' || exclusion.recognizerIds.includes(recognizerId);
+        return applies && contains(exclusion.region, point, definition.bounds);
+    });
+}
+function beginSession(definition, sample) {
+    const recognizers = {};
+    const transitions = [];
+    const previews = [];
+    for (const declaration of definition.recognizers) {
+        const snapshot = {
+            id: declaration.id,
+            previewActive: false,
+            ready: false,
+            state: 'began',
+        };
+        recognizers[declaration.id] = snapshot;
+        transitions.push({
+            reason: 'sequence-started',
+            recognizerId: declaration.id,
+            to: 'began',
+        });
+        const exclusion = isExcluded(definition, declaration.id, sample);
+        if (!contains(declaration.region, sample, definition.bounds)) {
+            snapshot.state = 'failed';
+            transitions.push({
+                from: 'began',
+                reason: 'outside-region',
+                recognizerId: declaration.id,
+                to: 'failed',
+            });
+            continue;
+        }
+        if (exclusion) {
+            snapshot.state = 'failed';
+            transitions.push({
+                from: 'began',
+                reason: `excluded:${exclusion.id}`,
+                recognizerId: declaration.id,
+                to: 'failed',
+            });
+            continue;
+        }
+        snapshot.state = 'possible';
+        transitions.push({
+            from: 'began',
+            reason: 'eligible',
+            recognizerId: declaration.id,
+            to: 'possible',
+        });
+        if (declaration.previewWhilePossible) {
+            snapshot.previewActive = true;
+            previews.push({ active: true, recognizerId: declaration.id });
+        }
+    }
+    const point = Object.freeze({ time: sample.time, x: sample.x, y: sample.y });
+    const session = Object.freeze({
+        activePointerIds: Object.freeze([sample.pointerId]),
+        current: point,
+        primaryPointerId: sample.pointerId,
+        recognizers: Object.freeze(Object.fromEntries(Object.entries(recognizers).map(([id, snapshot]) => [id, Object.freeze({ ...snapshot })]))),
+        start: point,
+        status: 'active',
+    });
+    return reducePrimaryPointer(definition, session, sample, transitions, previews);
+}
+function simultaneous(byId, first, second) {
+    if (first === second)
+        return true;
+    return byId.get(first)?.simultaneousWith?.includes(second) ?? false;
+}
+function requirementsFailed(declaration, recognizers) {
+    return (declaration.requiresFailureOf ?? []).every(id => recognizers[id]?.state === 'failed');
+}
+function resolveReadyRecognizers(definition, reduction) {
+    const byId = new Map(definition.recognizers.map(recognizer => [recognizer.id, recognizer]));
+    const existingWinners = definition.recognizers
+        .filter(recognizer => reduction.recognizers[recognizer.id]?.state === 'recognized')
+        .map(recognizer => recognizer.id);
+    const eligible = definition.recognizers
+        .map((recognizer, order) => ({ order, recognizer }))
+        .filter(({ recognizer }) => {
+        const snapshot = reduction.recognizers[recognizer.id];
+        return (snapshot?.state === 'possible' &&
+            snapshot.ready &&
+            requirementsFailed(recognizer, reduction.recognizers));
+    })
+        .sort((first, second) => second.recognizer.priority - first.recognizer.priority || first.order - second.order);
+    const winners = [...existingWinners];
+    for (const { recognizer } of eligible) {
+        if (winners.every(winner => simultaneous(byId, recognizer.id, winner))) {
+            const reason = reduction.recognizers[recognizer.id]?.readyReason ?? 'arena-won';
+            transition(reduction, recognizer.id, 'recognized', reason);
+            winners.push(recognizer.id);
+        }
+    }
+    if (winners.length === existingWinners.length)
+        return;
+    for (const recognizer of definition.recognizers) {
+        const snapshot = reduction.recognizers[recognizer.id];
+        if (!snapshot || snapshot.state !== 'possible')
+            continue;
+        // A local decision cannot cancel a platform recognizer. It stays possible
+        // until the adapter observes a native win or the sequence ends without one.
+        if ((recognizer.participation ?? 'javascript') === 'observed-native')
+            continue;
+        if (!winners.every(winner => simultaneous(byId, recognizer.id, winner))) {
+            transition(reduction, recognizer.id, 'canceled', `lost-to:${winners.join(',')}`);
+        }
+    }
+}
+function evaluatePossibleRecognizers(definition, session, sample, reduction) {
+    const decisions = new Map();
+    for (const declaration of definition.recognizers) {
+        const snapshot = reduction.recognizers[declaration.id];
+        if (snapshot?.state !== 'possible' ||
+            (declaration.participation ?? 'javascript') !== 'javascript') {
+            continue;
+        }
+        decisions.set(declaration.id, declaration.evaluate?.({
+            current: { time: sample.time, x: sample.x, y: sample.y },
+            declaration,
+            deltaX: sample.x - session.start.x,
+            deltaY: sample.y - session.start.y,
+            elapsed: Math.max(0, sample.time - session.start.time),
+            sample,
+            start: session.start,
+        }) ?? DEFER);
+    }
+    for (const declaration of definition.recognizers) {
+        const decision = decisions.get(declaration.id);
+        if (decision?.disposition === 'fail') {
+            transition(reduction, declaration.id, 'failed', decision.reason ?? 'recognizer-failed');
+        }
+    }
+    for (const declaration of definition.recognizers) {
+        const decision = decisions.get(declaration.id);
+        const snapshot = reduction.recognizers[declaration.id];
+        if (decision?.disposition === 'recognize' && snapshot?.state === 'possible') {
+            snapshot.ready = true;
+            snapshot.readyReason = decision.reason;
+        }
+    }
+    if (sample.phase === 'end') {
+        for (const declaration of definition.recognizers) {
+            const snapshot = reduction.recognizers[declaration.id];
+            if (snapshot?.state === 'possible' && !snapshot.ready) {
+                transition(reduction, declaration.id, 'failed', 'sequence-ended');
+            }
+        }
+    }
+    resolveReadyRecognizers(definition, reduction);
+}
+function reducePrimaryPointer(definition, session, sample, initialTransitions = [], initialPreviews = []) {
+    const reduction = {
+        previews: [...initialPreviews],
+        recognizers: cloneRecognizers(session),
+        transitions: [...initialTransitions],
+    };
+    const current = { time: sample.time, x: sample.x, y: sample.y };
+    if (sample.phase === 'cancel') {
+        for (const declaration of definition.recognizers) {
+            const snapshot = reduction.recognizers[declaration.id];
+            if (!snapshot)
+                continue;
+            if (snapshot.state === 'possible' && declaration.participation === 'observed-native') {
+                transition(reduction, declaration.id, 'failed', 'pointer-canceled-without-native-observation');
+            }
+            else if ((snapshot.state === 'possible' || snapshot.state === 'recognized') &&
+                (declaration.participation ?? 'javascript') === 'javascript') {
+                transition(reduction, declaration.id, 'canceled', 'pointer-canceled');
+            }
+        }
+        return {
+            previews: reduction.previews,
+            session: snapshotSession(session, reduction.recognizers, {
+                activePointerIds: session.activePointerIds.filter(pointerId => pointerId !== sample.pointerId),
+                current,
+                status: 'canceled',
+            }),
+            transitions: reduction.transitions,
+        };
+    }
+    evaluatePossibleRecognizers(definition, session, sample, reduction);
+    if (sample.phase === 'end') {
+        for (const declaration of definition.recognizers) {
+            const snapshot = reduction.recognizers[declaration.id];
+            if (snapshot?.state === 'possible') {
+                transition(reduction, declaration.id, 'failed', 'sequence-ended');
+            }
+        }
+    }
+    return {
+        previews: reduction.previews,
+        session: snapshotSession(session, reduction.recognizers, {
+            activePointerIds: sample.phase === 'end'
+                ? session.activePointerIds.filter(pointerId => pointerId !== sample.pointerId)
+                : session.activePointerIds,
+            current,
+            status: sample.phase === 'end' ? 'ended' : 'active',
+        }),
+        transitions: reduction.transitions,
+    };
+}
+function observeExternalRecognition(definition, session, input) {
+    const declaration = definition.recognizers.find(recognizer => recognizer.id === input.recognizerId);
+    if (!declaration || (declaration.participation ?? 'javascript') !== 'observed-native') {
+        return { ignored: 'inactive-session', previews: [], session, transitions: [] };
+    }
+    const reduction = {
+        previews: [],
+        recognizers: cloneRecognizers(session),
+        transitions: [],
+    };
+    const byId = new Map(definition.recognizers.map(recognizer => [recognizer.id, recognizer]));
+    transition(reduction, declaration.id, 'recognized', 'native-recognition-observed');
+    for (const recognizer of definition.recognizers) {
+        if (recognizer.id === declaration.id)
+            continue;
+        const snapshot = reduction.recognizers[recognizer.id];
+        if (snapshot &&
+            (snapshot.state === 'possible' || snapshot.state === 'recognized') &&
+            !simultaneous(byId, declaration.id, recognizer.id)) {
+            transition(reduction, recognizer.id, 'canceled', `lost-to:${declaration.id}`);
+        }
+    }
+    return {
+        previews: reduction.previews,
+        session: snapshotSession(session, reduction.recognizers, {
+            current: { ...session.current, time: input.time },
+        }),
+        transitions: reduction.transitions,
+    };
+}
+export function reduceGestureArena(definition, session, input) {
+    if (!session || session.status !== 'active') {
+        if (input.kind === 'pointer' && input.phase === 'start' && input.isPrimary) {
+            return beginSession(definition, input);
+        }
+        return { ignored: 'inactive-session', previews: [], session, transitions: [] };
+    }
+    if (input.pointerId !== session.primaryPointerId) {
+        if (input.kind === 'pointer' && input.phase === 'start') {
+            return {
+                ignored: 'foreign-pointer',
+                previews: [],
+                session: snapshotSession(session, cloneRecognizers(session), {
+                    activePointerIds: session.activePointerIds.includes(input.pointerId)
+                        ? session.activePointerIds
+                        : [...session.activePointerIds, input.pointerId],
+                }),
+                transitions: [],
+            };
+        }
+        if (input.kind === 'pointer' && (input.phase === 'end' || input.phase === 'cancel')) {
+            return {
+                ignored: 'foreign-pointer',
+                previews: [],
+                session: snapshotSession(session, cloneRecognizers(session), {
+                    activePointerIds: session.activePointerIds.filter(pointerId => pointerId !== input.pointerId),
+                }),
+                transitions: [],
+            };
+        }
+        return { ignored: 'foreign-pointer', previews: [], session, transitions: [] };
+    }
+    if (input.kind === 'external-recognition') {
+        return observeExternalRecognition(definition, session, input);
+    }
+    if (input.phase === 'start') {
+        return { ignored: 'duplicate-primary', previews: [], session, transitions: [] };
+    }
+    return reducePrimaryPointer(definition, session, input);
+}
+export function recognizerState(session, recognizerId) {
+    const snapshot = session.recognizers[recognizerId];
+    if (!snapshot) {
+        throw new Error(`Satin gesture arena has no recognizer named "${recognizerId}".`);
+    }
+    return snapshot;
+}

package/dist/gestures/existingCompetitors.d.ts

@@ -0,0 +1,79 @@
+import { type GestureArenaDefinition, type GestureArenaSession, type GestureBounds, type GestureExclusion, type GestureRecognizerDeclaration } from './arena.js';
+export declare const INTERACTIVE_POP_RECOGNIZER_ID = "interactive-pop";
+export declare const NATIVE_SCROLL_RECOGNIZER_ID = "native-scroll";
+export declare const PRESS_RECOGNIZER_ID = "press";
+export declare const interactivePopRecognizer: Readonly<{
+    axis: "horizontal";
+    evaluate(context: Readonly<{
+        current: Readonly<{
+            time: number;
+            x: number;
+            y: number;
+        }>;
+        declaration: GestureRecognizerDeclaration;
+        deltaX: number;
+        deltaY: number;
+        elapsed: number;
+        sample: import("./arena.js").NormalizedPointerSample;
+        start: Readonly<{
+            time: number;
+            x: number;
+            y: number;
+        }>;
+    }>): import("./arena.js").GestureDecision;
+    hysteresis: Readonly<{
+        activationDistance: 30;
+        claimDistance: 10;
+    }>;
+    id: string;
+    priority: number;
+    region: Readonly<{
+        readonly kind: 'all';
+    }>;
+}>;
+export declare const pressRecognizer: Readonly<{
+    axis: "any";
+    evaluate(context: Readonly<{
+        current: Readonly<{
+            time: number;
+            x: number;
+            y: number;
+        }>;
+        declaration: GestureRecognizerDeclaration;
+        deltaX: number;
+        deltaY: number;
+        elapsed: number;
+        sample: import("./arena.js").NormalizedPointerSample;
+        start: Readonly<{
+            time: number;
+            x: number;
+            y: number;
+        }>;
+    }>): import("./arena.js").GestureDecision;
+    hysteresis: Readonly<{
+        retentionDistance: 69;
+    }>;
+    id: string;
+    previewWhilePossible: true;
+    priority: number;
+    region: Readonly<{
+        readonly kind: 'all';
+    }>;
+}>;
+export declare const nativeScrollRecognizer: Readonly<{
+    axis: "vertical";
+    hysteresis: Readonly<{}>;
+    id: string;
+    participation: "observed-native";
+    priority: number;
+    region: Readonly<{
+        readonly kind: 'all';
+    }>;
+}>;
+export declare function createExistingCompetitorArena(bounds: GestureBounds, exclusions?: readonly GestureExclusion[]): GestureArenaDefinition;
+/**
+ * The early claim owns the touch at 10 points, but the screen stays still until
+ * the separately measured 30-point visibility gate.
+ */
+export declare function interactivePopVisualProgress(session: GestureArenaSession, width: number): number;
+export declare function interactivePopReleaseTarget(session: GestureArenaSession, width: number): "cancel" | "complete";

package/dist/gestures/existingCompetitors.js

@@ -0,0 +1,82 @@
+import { NAVIGATION_DIRECTION_LOCK_PX, NAVIGATION_HORIZONTAL_INTENT_PX, shouldCompleteInteractivePop, } from '../navigation/motion.js';
+import { PRESSABLE_RETENTION_OFFSET_PX } from '../press/tokens.js';
+import { createGestureArena, deferGesture, failGesture, recognizeGesture, recognizerState, } from './arena.js';
+export const INTERACTIVE_POP_RECOGNIZER_ID = 'interactive-pop';
+export const NATIVE_SCROLL_RECOGNIZER_ID = 'native-scroll';
+export const PRESS_RECOGNIZER_ID = 'press';
+const allRegion = Object.freeze({ kind: 'all' });
+export const interactivePopRecognizer = Object.freeze({
+    axis: 'horizontal',
+    evaluate(context) {
+        if (context.sample.phase === 'end') {
+            return failGesture('released-before-horizontal-claim');
+        }
+        if (context.sample.phase === 'start')
+            return deferGesture();
+        const absoluteX = Math.abs(context.deltaX);
+        const absoluteY = Math.abs(context.deltaY);
+        if (Math.max(absoluteX, absoluteY) < NAVIGATION_DIRECTION_LOCK_PX) {
+            return deferGesture();
+        }
+        if (context.deltaX > 0 && absoluteX > absoluteY) {
+            return recognizeGesture('rightward-horizontal-claim');
+        }
+        return failGesture(absoluteY >= absoluteX ? 'vertical-intent' : 'leftward-intent');
+    },
+    hysteresis: Object.freeze({
+        activationDistance: NAVIGATION_HORIZONTAL_INTENT_PX,
+        claimDistance: NAVIGATION_DIRECTION_LOCK_PX,
+    }),
+    id: INTERACTIVE_POP_RECOGNIZER_ID,
+    priority: 100,
+    region: allRegion,
+});
+export const pressRecognizer = Object.freeze({
+    axis: 'any',
+    evaluate(context) {
+        return context.sample.phase === 'end' ? recognizeGesture('pointer-released') : deferGesture();
+    },
+    hysteresis: Object.freeze({
+        retentionDistance: PRESSABLE_RETENTION_OFFSET_PX,
+    }),
+    id: PRESS_RECOGNIZER_ID,
+    previewWhilePossible: true,
+    priority: 0,
+    region: allRegion,
+});
+export const nativeScrollRecognizer = Object.freeze({
+    axis: 'vertical',
+    hysteresis: Object.freeze({}),
+    id: NATIVE_SCROLL_RECOGNIZER_ID,
+    participation: 'observed-native',
+    priority: 0,
+    region: allRegion,
+});
+export function createExistingCompetitorArena(bounds, exclusions = []) {
+    return createGestureArena({
+        bounds,
+        exclusions,
+        recognizers: [interactivePopRecognizer, pressRecognizer, nativeScrollRecognizer],
+    });
+}
+/**
+ * The early claim owns the touch at 10 points, but the screen stays still until
+ * the separately measured 30-point visibility gate.
+ */
+export function interactivePopVisualProgress(session, width) {
+    if (width <= 0 ||
+        recognizerState(session, INTERACTIVE_POP_RECOGNIZER_ID).state !== 'recognized') {
+        return 0;
+    }
+    const deltaX = session.current.x - session.start.x;
+    if (deltaX < NAVIGATION_HORIZONTAL_INTENT_PX)
+        return 0;
+    return Math.min(1, Math.max(0, deltaX / width));
+}
+export function interactivePopReleaseTarget(session, width) {
+    const elapsedSeconds = Math.max(0.001, (session.current.time - session.start.time) / 1_000);
+    const deltaX = session.current.x - session.start.x;
+    const progress = width <= 0 ? 0 : Math.min(1, Math.max(0, deltaX / width));
+    const velocityPointsPerSecond = deltaX / elapsedSeconds;
+    return shouldCompleteInteractivePop(progress, velocityPointsPerSecond) ? 'complete' : 'cancel';
+}

package/dist/gestures/gesture.d.ts

@@ -0,0 +1,62 @@
+import { type GestureDecision, type GestureRecognizerContext } from './arena.js';
+export type GesturePoint = Readonly<{
+    x: number;
+    y: number;
+}>;
+export type DragGestureValue = Readonly<{
+    location: GesturePoint;
+    startLocation: GesturePoint;
+    translation: GesturePoint;
+    velocity: GesturePoint;
+}>;
+export type MagnifyGestureValue = Readonly<{
+    magnification: number;
+    startAnchor: GesturePoint;
+}>;
+export type GestureState<Value> = Readonly<{
+    update(value: Value): void;
+    reset(): void;
+}>;
+type Callbacks<Value> = Readonly<{
+    onChanged?: (value: Value) => void;
+    onEnded?: (value: Value) => void;
+    onCancelled?: () => void;
+    state?: GestureState<Value>;
+}>;
+export type GestureSample = Readonly<{
+    drag: DragGestureValue;
+    magnify: MagnifyGestureValue | undefined;
+}>;
+export type Gesture = Readonly<{
+    kind: 'drag' | 'longPress' | 'tap' | 'magnify';
+    axis: 'horizontal' | 'vertical' | 'any';
+    delay?: number;
+    count?: number;
+    evaluate(context: GestureRecognizerContext, sample: GestureSample): GestureDecision;
+    changed(sample: GestureSample): void;
+    ended(sample: GestureSample): void;
+    cancelled(): void;
+}>;
+/** A React value plus a gesture-owned update/reset binding. Cancellation and release
+ * restore the initial value; no mutable proxy is exposed to application code. */
+export declare function useGestureState<Value>(initialValue: Value): readonly [Value, GestureState<Value>];
+export type DragGestureOptions = Callbacks<DragGestureValue> & Readonly<{
+    minimumDistance?: number;
+    axis?: Gesture['axis'];
+}>;
+export declare function DragGesture({ minimumDistance, axis, ...options }?: DragGestureOptions): Gesture;
+export type LongPressGestureOptions = Callbacks<boolean> & Readonly<{
+    minimumDurationMs?: number;
+    maximumDistance?: number;
+}>;
+export declare function LongPressGesture({ minimumDurationMs, maximumDistance, ...options }?: LongPressGestureOptions): Gesture;
+export type TapGestureOptions = Callbacks<GesturePoint> & Readonly<{
+    count?: number;
+    maximumDistance?: number;
+}>;
+export declare function TapGesture({ count, maximumDistance, ...options }?: TapGestureOptions): Gesture;
+export type MagnifyGestureOptions = Callbacks<MagnifyGestureValue> & Readonly<{
+    minimumScaleDelta?: number;
+}>;
+export declare function MagnifyGesture({ minimumScaleDelta, ...options }?: MagnifyGestureOptions): Gesture;
+export {};