react-native-gesture-handler
Version:
Declarative API exposing native platform touch and gesture system to React Native
137 lines (112 loc) • 3.86 kB
text/typescript
import { PointerType } from '../../PointerType';
import type { AdaptedEvent } from '../interfaces';
import { EventTypes } from '../interfaces';
import { viewportToLocal } from '../utils';
import EventManager from './EventManager';
export default class KeyboardEventManager extends EventManager<HTMLElement> {
private static activationKeys = new Set(['Enter', ' ']);
private static cancelationKeys = new Set(['Tab']);
private keyPointer: string | null = null;
private static registeredStaticListeners = false;
private static instances: Set<KeyboardEventManager> = new Set();
private static keyUpStaticCallback = (event: KeyboardEvent): void => {
// We need a global listener, as in some cases, keyUp event gets stop-propagated.
// Then, if we used only component-level listeners the gesture would never end,
// causing other gestues to fail.
if (!this.activationKeys.has(event.key)) {
return;
}
this.instances.forEach((item) => {
item.onKeyUp(event);
});
};
private keyDownCallback = (event: KeyboardEvent): void => {
if (this.keyPointer !== null) {
if (KeyboardEventManager.cancelationKeys.has(event.key)) {
this.dispatchEvent(event, EventTypes.CANCEL);
this.keyPointer = null;
}
return;
}
if (!KeyboardEventManager.activationKeys.has(event.key) || event.repeat) {
return;
}
this.keyPointer = event.key;
this.dispatchEvent(event, EventTypes.DOWN);
};
private onKeyUp = (event: KeyboardEvent): void => {
if (this.keyPointer !== event.key) {
return;
}
this.dispatchEvent(event, EventTypes.UP);
this.keyPointer = null;
};
private dispatchEvent(event: KeyboardEvent, eventType: EventTypes) {
if (!(event.target instanceof HTMLElement)) {
return;
}
const adaptedEvent = this.mapEvent(event, eventType);
switch (eventType) {
case EventTypes.UP:
this.onPointerUp(adaptedEvent);
break;
case EventTypes.DOWN:
this.onPointerDown(adaptedEvent);
break;
case EventTypes.CANCEL:
this.onPointerCancel(adaptedEvent);
break;
}
}
public registerListeners(): void {
this.view.addEventListener('keydown', this.keyDownCallback);
KeyboardEventManager.instances.add(this);
if (!KeyboardEventManager.registeredStaticListeners) {
KeyboardEventManager.registeredStaticListeners = true;
document.addEventListener(
'keyup',
KeyboardEventManager.keyUpStaticCallback,
{ capture: true }
);
}
}
public unregisterListeners(): void {
this.view.removeEventListener('keydown', this.keyDownCallback);
KeyboardEventManager.instances.delete(this);
if (KeyboardEventManager.instances.size === 0) {
document.removeEventListener(
'keyup',
KeyboardEventManager.keyUpStaticCallback,
{ capture: true }
);
KeyboardEventManager.registeredStaticListeners = false;
}
}
public override resetManager(): void {
super.resetManager();
this.keyPointer = null;
}
protected mapEvent(
event: KeyboardEvent,
eventType: EventTypes
): AdaptedEvent {
const viewRect = (event.target as HTMLElement).getBoundingClientRect();
// The center of the focused element, which is where its own center lands
// whatever the transforms.
const viewportPosition = {
x: viewRect?.x + viewRect?.width / 2,
y: viewRect?.y + viewRect?.height / 2,
};
const relativePosition = viewportToLocal(this.view, viewportPosition);
return {
x: viewportPosition.x,
y: viewportPosition.y,
offsetX: relativePosition.x,
offsetY: relativePosition.y,
pointerId: 0,
eventType: eventType,
pointerType: PointerType.KEY,
time: event.timeStamp,
};
}
}