diff --git a/client/src/native/keyboardFields.test.ts b/client/src/native/keyboardFields.test.ts
index ba6f77789..783c1ae50 100644
--- a/client/src/native/keyboardFields.test.ts
+++ b/client/src/native/keyboardFields.test.ts
@@ -143,3 +143,56 @@ describe('closeOnDone', () => {
expect(document.activeElement).toBe(handled);
});
});
+
+describe('closeOnTapAway', () => {
+ function touch(target: Element, type: 'touchstart' | 'touchend', x: number, y: number) {
+ const e = new Event(type, { bubbles: true, cancelable: true });
+ const point = [{ clientX: x, clientY: y }];
+ Object.defineProperty(e, type === 'touchstart' ? 'touches' : 'changedTouches', { value: point });
+ if (type === 'touchend') Object.defineProperty(e, 'touches', { value: [] });
+ target.dispatchEvent(e);
+ }
+ function tap(target: Element, moveBy = 0) {
+ touch(target, 'touchstart', 100, 100);
+ touch(target, 'touchend', 100, 100 + moveBy);
+ }
+ function sheet(): { notes: HTMLTextAreaElement; title: HTMLInputElement; label: HTMLElement; stop: () => void } {
+ document.body.innerHTML =
+ '
';
+ const stop = prepareKeyboardFields(document);
+ return {
+ notes: document.getElementById('notes') as HTMLTextAreaElement,
+ title: document.getElementById('title') as HTMLInputElement,
+ label: document.getElementById('label') as HTMLElement,
+ stop,
+ };
+ }
+
+ it('closes the keyboard of a textarea when the sheet beside it is tapped', () => {
+ const { notes, label, stop } = sheet();
+ notes.focus();
+ tap(label);
+ expect(document.activeElement).not.toBe(notes);
+ stop();
+ });
+
+ it('keeps it while the finger scrolls, taps the field itself or moves to another field', () => {
+ const { notes, title, label, stop } = sheet();
+ notes.focus();
+ tap(label, 40);
+ expect(document.activeElement).toBe(notes);
+ tap(notes);
+ expect(document.activeElement).toBe(notes);
+ tap(title);
+ expect(document.activeElement).toBe(notes);
+ stop();
+ });
+
+ it('stops listening when told to', () => {
+ const { notes, label, stop } = sheet();
+ stop();
+ notes.focus();
+ tap(label);
+ expect(document.activeElement).toBe(notes);
+ });
+});
diff --git a/client/src/native/keyboardFields.ts b/client/src/native/keyboardFields.ts
index c0d256d18..16819097d 100644
--- a/client/src/native/keyboardFields.ts
+++ b/client/src/native/keyboardFields.ts
@@ -24,6 +24,9 @@
* nothing. When no handler took the Enter (the field still has focus and the
* same text a moment later) the field lets go of the focus. A field that acts
* on Enter and clears itself, such as a list that adds the next item, keeps it.
+ *
+ * A tap away from any field closes the keyboard too, which is the only way out of
+ * a textarea: its return key writes a new line.
*/
const SKIP_TYPES = new Set([
@@ -127,6 +130,43 @@ function closeOnDone(e: KeyboardEvent): void {
}, 0);
}
+/** A field that holds the keyboard open while it has the focus. */
+function typedInto(el: Element | null): el is HTMLElement {
+ if (el instanceof HTMLTextAreaElement) return !el.readOnly;
+ if (el instanceof HTMLInputElement) return !SKIP_TYPES.has(el.type) && !el.readOnly;
+ return el instanceof HTMLElement && el.isContentEditable;
+}
+
+const EDITABLE = 'input, textarea, select, [contenteditable]:not([contenteditable="false"])';
+/** How far a finger may travel and still count as a tap rather than a scroll, in CSS pixels. */
+const TAP_SLOP = 10;
+
+/**
+ * A tap away from the field closes the keyboard. A textarea keeps its return key
+ * for new lines, and the app hides the keyboard's bar with its "done" button, so
+ * otherwise nothing closes it and it covers the rest of the sheet. A tap on another
+ * field moves the focus there instead, and a scroll leaves the keyboard open.
+ */
+function closeOnTapAway(doc: Document): { start: (e: TouchEvent) => void; end: (e: TouchEvent) => void } {
+ let from: { x: number; y: number } | null = null;
+ return {
+ start(e) {
+ const touch = e.touches[0];
+ from = e.touches.length === 1 && touch ? { x: touch.clientX, y: touch.clientY } : null;
+ },
+ end(e) {
+ const touch = e.changedTouches[0];
+ const tapped = from && touch && Math.hypot(touch.clientX - from.x, touch.clientY - from.y) <= TAP_SLOP;
+ from = null;
+ const field = doc.activeElement;
+ if (!tapped || !typedInto(field)) return;
+ const target = e.target instanceof Element ? e.target : null;
+ if (target && (field.contains(target) || target.closest(EDITABLE))) return;
+ field.blur();
+ },
+ };
+}
+
export function prepareKeyboardFields(doc: Document = document): () => void {
// On the touch, before the focus: the keyboard is set up as the field takes it.
const onTouch = (e: Event) => prepareField(e.target instanceof Element ? e.target.closest('input') : null);
@@ -135,7 +175,12 @@ export function prepareKeyboardFields(doc: Document = document): () => void {
doc.addEventListener('focusin', onFocus, true);
// Capturing, so the text is read before the field's own handler can change it.
doc.addEventListener('keydown', closeOnDone, true);
+ const tapAway = closeOnTapAway(doc);
+ doc.addEventListener('touchstart', tapAway.start, { capture: true, passive: true });
+ doc.addEventListener('touchend', tapAway.end, { capture: true, passive: true });
return () => {
+ doc.removeEventListener('touchstart', tapAway.start, { capture: true });
+ doc.removeEventListener('touchend', tapAway.end, { capture: true });
doc.removeEventListener('touchstart', onTouch, { capture: true });
doc.removeEventListener('focusin', onFocus, true);
doc.removeEventListener('keydown', closeOnDone, true);