expo-key-event/build/hooks/useKeyEvent.web.js

Provides an interface for reading key events such as from external bluetooth keyboards on Android, iOS and Web.

import { useCallback, useEffect, useState } from "react";
export function useKeyEvent(optionsOrListenOnMount, preventReload, listenToRelease) {
    // Backwards compatibility: detect if using old API (boolean) or new API (object/undefined)
    let options;
    if (typeof optionsOrListenOnMount === "boolean") {
        // Legacy API: positional parameters (boolean explicitly passed)
        options = {
            listenOnMount: optionsOrListenOnMount,
            preventReload: preventReload ?? false,
            listenToRelease: listenToRelease ?? false,
        };
    }
    else {
        // New API: options object or undefined (defaults to {})
        options = optionsOrListenOnMount ?? {};
    }
    return useKeyEventImpl(options);
}
function useKeyEventImpl({ listenOnMount = true, preventReload = false, listenToRelease = false, captureModifiers = false, }) {
    const [keyEvent, setKeyEvent] = useState(null);
    const [keyReleaseEvent, setKeyReleaseEvent] = useState(null);
    const onKeyDown = useCallback((event) => {
        const pressEvent = {
            key: event.code,
            eventType: "press",
        };
        if (captureModifiers) {
            pressEvent.shiftKey = event.shiftKey;
            pressEvent.ctrlKey = event.ctrlKey;
            pressEvent.altKey = event.altKey;
            pressEvent.metaKey = event.metaKey;
            pressEvent.repeat = event.repeat;
        }
        setKeyEvent(pressEvent);
    }, [captureModifiers]);
    const onKeyUp = useCallback((event) => {
        const releaseEvent = {
            key: event.code,
            eventType: "release",
        };
        if (captureModifiers) {
            releaseEvent.shiftKey = event.shiftKey;
            releaseEvent.ctrlKey = event.ctrlKey;
            releaseEvent.altKey = event.altKey;
            releaseEvent.metaKey = event.metaKey;
            releaseEvent.repeat = false; // Key up events are never repeats
        }
        setKeyReleaseEvent(releaseEvent);
    }, [captureModifiers]);
    const startListening = useCallback(() => {
        addEventListener("keydown", onKeyDown);
        if (listenToRelease) {
            addEventListener("keyup", onKeyUp);
        }
    }, [onKeyDown, onKeyUp, listenToRelease]);
    const stopListening = useCallback(() => {
        removeEventListener("keydown", onKeyDown);
        if (listenToRelease) {
            removeEventListener("keyup", onKeyUp);
        }
    }, [onKeyDown, onKeyUp, listenToRelease]);
    useEffect(() => {
        if (listenOnMount)
            startListening();
        return () => {
            stopListening();
        };
    }, [listenOnMount, startListening, stopListening]);
    return {
        /**
         * Start listening for key events
         */
        startListening,
        /**
         * Stop listening for key events
         */
        stopListening,
        keyEvent,
        keyReleaseEvent,
    };
}
//# sourceMappingURL=useKeyEvent.web.js.map