Return focus to the chat composer when the desktop window comes back
On web the engine closes the text connection on the editing element's blur, which the browser fires just before the window blur, so the field is already unfocused when lifecycle inactive arrives and FocusManager's own suspend and resume restores only the route scope. Remember whether the composer held (or had just lost) focus when the window left, and refocus it on resume, keeping the caret and selection, unless another control took focus or a dialog, sheet or route covers the chat. Desktop hosts only, so phones never get an unasked on-screen keyboard.
This commit is contained in:
@@ -23,6 +23,7 @@ import 'chat_composer_controller.dart';
|
||||
import '../ui/transcript/chat_attachment_frame.dart';
|
||||
import '../../../ui/adaptive/glass_pill.dart';
|
||||
import 'chat_reading_width.dart';
|
||||
import 'composer_focus_restore.dart';
|
||||
|
||||
/// The composer's placeholder when the chat names no working directory.
|
||||
const String chatComposerPlaceholder = 'Message the agent';
|
||||
@@ -136,6 +137,7 @@ class _ChatComposerBarState extends State<ChatComposerBar> {
|
||||
text: widget.composer.draft,
|
||||
);
|
||||
final FocusNode _focus = FocusNode(debugLabel: 'chat-composer');
|
||||
late final ComposerFocusRestorer _focusRestorer;
|
||||
final ChatAttachmentDraft _attachments = ChatAttachmentDraft();
|
||||
|
||||
/// The picked bytes behind each chip, positionally aligned with the draft's
|
||||
@@ -176,11 +178,22 @@ class _ChatComposerBarState extends State<ChatComposerBar> {
|
||||
@override
|
||||
void initState() {
|
||||
super.initState();
|
||||
_focusRestorer = ComposerFocusRestorer(
|
||||
focus: _focus,
|
||||
canRestore: _composerIsCurrent,
|
||||
);
|
||||
widget.composer.addListener(_syncDraft);
|
||||
_listenForPaste();
|
||||
unawaited(widget.composer.loadDraft());
|
||||
}
|
||||
|
||||
/// Whether the composer is still where the operator works: mounted, shown,
|
||||
/// and not covered by a dialog, sheet or another pushed route.
|
||||
bool _composerIsCurrent() =>
|
||||
mounted &&
|
||||
TickerMode.valuesOf(context).enabled &&
|
||||
(ModalRoute.of(context)?.isCurrent ?? true);
|
||||
|
||||
@override
|
||||
void didUpdateWidget(covariant ChatComposerBar oldWidget) {
|
||||
super.didUpdateWidget(oldWidget);
|
||||
@@ -603,6 +616,7 @@ class _ChatComposerBarState extends State<ChatComposerBar> {
|
||||
void dispose() {
|
||||
_stopListeningForPaste();
|
||||
widget.composer.removeListener(_syncDraft);
|
||||
_focusRestorer.dispose();
|
||||
_text.dispose();
|
||||
_focus.dispose();
|
||||
super.dispose();
|
||||
|
||||
@@ -0,0 +1,85 @@
|
||||
import 'package:flutter/foundation.dart';
|
||||
import 'package:flutter/widgets.dart';
|
||||
|
||||
/// How long before the window loses focus a composer blur still counts as
|
||||
/// caused by that switch. The web engine closes the text connection (and so
|
||||
/// unfocuses the field) on the input's own `blur`, which the browser fires
|
||||
/// just before the window's `blur` that Flutter reports as `inactive`.
|
||||
const Duration composerBlurGrace = Duration(milliseconds: 250);
|
||||
|
||||
/// Whether this host restores composer focus when its window comes back.
|
||||
/// Only desktop hosts (native or a desktop browser): on phones, focusing the
|
||||
/// field on resume would pop the on-screen keyboard unasked.
|
||||
bool get composerFocusRestoreSupported => switch (defaultTargetPlatform) {
|
||||
TargetPlatform.macOS ||
|
||||
TargetPlatform.windows ||
|
||||
TargetPlatform.linux => true,
|
||||
_ => false,
|
||||
};
|
||||
|
||||
/// Returns focus to the composer [focus] when the app window regains focus,
|
||||
/// if the composer held it when the window lost it, like chat web apps do.
|
||||
///
|
||||
/// On web the engine reports window `blur` as [AppLifecycleState.inactive]
|
||||
/// and window `focus` (or the tab becoming visible) as `resumed`. Nothing is
|
||||
/// restored when, by then, another control holds focus or [canRestore] says
|
||||
/// the composer is no longer the operator's place (a dialog, sheet or other
|
||||
/// route covers it). The text controller keeps the caret and selection while
|
||||
/// unfocused, so requesting focus puts them back as they were.
|
||||
class ComposerFocusRestorer {
|
||||
ComposerFocusRestorer({
|
||||
required this.focus,
|
||||
required this.canRestore,
|
||||
bool? enabled,
|
||||
DateTime Function()? now,
|
||||
}) : _now = now ?? DateTime.now {
|
||||
if (!(enabled ?? composerFocusRestoreSupported)) return;
|
||||
focus.addListener(_onFocusChange);
|
||||
_listener = AppLifecycleListener(onStateChange: _onStateChange);
|
||||
}
|
||||
|
||||
final FocusNode focus;
|
||||
final bool Function() canRestore;
|
||||
final DateTime Function() _now;
|
||||
AppLifecycleListener? _listener;
|
||||
|
||||
bool _away = false;
|
||||
bool _restore = false;
|
||||
DateTime? _blurredAt;
|
||||
|
||||
void _onFocusChange() {
|
||||
_blurredAt = focus.hasPrimaryFocus ? null : _now();
|
||||
}
|
||||
|
||||
bool get _blurredJustNow {
|
||||
final at = _blurredAt;
|
||||
return at != null && _now().difference(at) <= composerBlurGrace;
|
||||
}
|
||||
|
||||
void _onStateChange(AppLifecycleState state) {
|
||||
if (state != AppLifecycleState.resumed) {
|
||||
// Only the first step away from resumed decides; later inactive/hidden
|
||||
// steps of the same absence must not overwrite it.
|
||||
if (!_away) {
|
||||
_away = true;
|
||||
_restore = focus.hasPrimaryFocus || _blurredJustNow;
|
||||
}
|
||||
return;
|
||||
}
|
||||
final restore = _away && _restore;
|
||||
_away = false;
|
||||
_restore = false;
|
||||
if (restore && _focusIsFree && canRestore()) focus.requestFocus();
|
||||
}
|
||||
|
||||
/// True when no other control took focus while the window was away.
|
||||
bool get _focusIsFree {
|
||||
final current = FocusManager.instance.primaryFocus;
|
||||
return current == null || current == focus || current is FocusScopeNode;
|
||||
}
|
||||
|
||||
void dispose() {
|
||||
_listener?.dispose();
|
||||
if (_listener != null) focus.removeListener(_onFocusChange);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,198 @@
|
||||
import 'package:flutter/material.dart';
|
||||
import 'package:flutter_test/flutter_test.dart';
|
||||
import 'package:pipelines_app/features/chat/conversation/composer_focus_restore.dart';
|
||||
|
||||
import 'chat_composer_bar_fixtures.dart';
|
||||
|
||||
final _desktop = TargetPlatformVariant.only(TargetPlatform.macOS);
|
||||
final _phone = TargetPlatformVariant.only(TargetPlatform.android);
|
||||
|
||||
final _field = find.byKey(const Key('chat-composer-field'));
|
||||
|
||||
FocusNode _composerFocus(WidgetTester tester) => tester
|
||||
.widget<EditableText>(
|
||||
find.descendant(of: _field, matching: find.byType(EditableText)),
|
||||
)
|
||||
.focusNode;
|
||||
|
||||
TextEditingController _controller(WidgetTester tester) => tester
|
||||
.widget<EditableText>(
|
||||
find.descendant(of: _field, matching: find.byType(EditableText)),
|
||||
)
|
||||
.controller;
|
||||
|
||||
/// The window loses focus (web: window `blur`) and comes back (`focus`).
|
||||
Future<void> _switchAway(
|
||||
WidgetTester tester, {
|
||||
Future<void> Function()? whileAway,
|
||||
bool viaHidden = false,
|
||||
}) async {
|
||||
tester.binding.handleAppLifecycleStateChanged(AppLifecycleState.inactive);
|
||||
if (viaHidden) {
|
||||
tester.binding.handleAppLifecycleStateChanged(AppLifecycleState.hidden);
|
||||
tester.binding.handleAppLifecycleStateChanged(AppLifecycleState.inactive);
|
||||
}
|
||||
await tester.pump();
|
||||
if (whileAway != null) await whileAway();
|
||||
tester.binding.handleAppLifecycleStateChanged(AppLifecycleState.resumed);
|
||||
await tester.pump();
|
||||
}
|
||||
|
||||
Future<ComposerBarGateway> _open(WidgetTester tester) async {
|
||||
final gateway = ComposerBarGateway()..page = fixtureTurn();
|
||||
addTearDown(gateway.close);
|
||||
await tester.pumpWidget(composerThread(gateway));
|
||||
await tester.pumpAndSettle();
|
||||
return gateway;
|
||||
}
|
||||
|
||||
Future<void> _typeWithCaret(WidgetTester tester) async {
|
||||
await tester.showKeyboard(_field);
|
||||
await tester.enterText(_field, 'hello world');
|
||||
_controller(tester).selection = const TextSelection(
|
||||
baseOffset: 2,
|
||||
extentOffset: 5,
|
||||
);
|
||||
await tester.pump();
|
||||
}
|
||||
|
||||
void main() {
|
||||
testWidgets(
|
||||
'focus and selection return to the composer when the window comes back',
|
||||
(tester) async {
|
||||
await _open(tester);
|
||||
await _typeWithCaret(tester);
|
||||
// The web engine closes the text connection on the editing element's
|
||||
// blur, which the browser fires just before the window's blur; the
|
||||
// framework has unfocused the field by the time `inactive` arrives, so
|
||||
// FocusManager's own suspend/resume cannot bring it back.
|
||||
_composerFocus(tester).unfocus();
|
||||
await tester.pump();
|
||||
expect(_composerFocus(tester).hasFocus, isFalse);
|
||||
await _switchAway(tester);
|
||||
expect(_composerFocus(tester).hasPrimaryFocus, isTrue);
|
||||
expect(
|
||||
_controller(tester).selection,
|
||||
const TextSelection(baseOffset: 2, extentOffset: 5),
|
||||
);
|
||||
},
|
||||
variant: _desktop,
|
||||
);
|
||||
|
||||
testWidgets(
|
||||
'switching tabs (inactive, hidden, inactive, resumed) restores too',
|
||||
(tester) async {
|
||||
await _open(tester);
|
||||
await _typeWithCaret(tester);
|
||||
_composerFocus(tester).unfocus();
|
||||
await tester.pump();
|
||||
await _switchAway(tester, viaHidden: true);
|
||||
expect(_composerFocus(tester).hasPrimaryFocus, isTrue);
|
||||
},
|
||||
variant: _desktop,
|
||||
);
|
||||
|
||||
testWidgets('nothing is restored when the composer was not focused', (
|
||||
tester,
|
||||
) async {
|
||||
await _open(tester);
|
||||
expect(_composerFocus(tester).hasFocus, isFalse);
|
||||
await _switchAway(tester);
|
||||
expect(_composerFocus(tester).hasFocus, isFalse);
|
||||
}, variant: _desktop);
|
||||
|
||||
testWidgets('nothing is restored when another control holds focus', (
|
||||
tester,
|
||||
) async {
|
||||
await _open(tester);
|
||||
await _typeWithCaret(tester);
|
||||
final other = FocusNode(debugLabel: 'other');
|
||||
addTearDown(other.dispose);
|
||||
await _switchAway(
|
||||
tester,
|
||||
whileAway: () async {
|
||||
// A focusable outside the field takes focus while away.
|
||||
other
|
||||
.attach(tester.element(_field))
|
||||
.reparent(parent: FocusManager.instance.rootScope);
|
||||
other.requestFocus();
|
||||
await tester.pump();
|
||||
},
|
||||
);
|
||||
expect(other.hasPrimaryFocus, isTrue);
|
||||
expect(_composerFocus(tester).hasFocus, isFalse);
|
||||
}, variant: _desktop);
|
||||
|
||||
testWidgets('nothing is restored while a dialog covers the chat', (
|
||||
tester,
|
||||
) async {
|
||||
await _open(tester);
|
||||
await _typeWithCaret(tester);
|
||||
await _switchAway(
|
||||
tester,
|
||||
whileAway: () async {
|
||||
showDialog<void>(
|
||||
context: tester.element(_field),
|
||||
builder: (_) => const AlertDialog(content: Text('dialog')),
|
||||
);
|
||||
await tester.pumpAndSettle();
|
||||
FocusManager.instance.primaryFocus?.unfocus();
|
||||
await tester.pump();
|
||||
},
|
||||
);
|
||||
expect(find.text('dialog'), findsOneWidget);
|
||||
expect(_composerFocus(tester).hasFocus, isFalse);
|
||||
}, variant: _desktop);
|
||||
|
||||
testWidgets('phones do not refocus (no unasked on-screen keyboard)', (
|
||||
tester,
|
||||
) async {
|
||||
await _open(tester);
|
||||
await _typeWithCaret(tester);
|
||||
await _switchAway(
|
||||
tester,
|
||||
whileAway: () async {
|
||||
_composerFocus(tester).unfocus();
|
||||
await tester.pump();
|
||||
},
|
||||
);
|
||||
expect(_composerFocus(tester).hasFocus, isFalse);
|
||||
}, variant: _phone);
|
||||
|
||||
testWidgets('a blur well before the window left is the operator\'s own', (
|
||||
tester,
|
||||
) async {
|
||||
var now = DateTime(2026);
|
||||
final focus = FocusNode();
|
||||
final restorer = ComposerFocusRestorer(
|
||||
focus: focus,
|
||||
canRestore: () => true,
|
||||
enabled: true,
|
||||
now: () => now,
|
||||
);
|
||||
addTearDown(() {
|
||||
restorer.dispose();
|
||||
focus.dispose();
|
||||
});
|
||||
await tester.pumpWidget(
|
||||
MaterialApp(
|
||||
home: Material(child: TextField(focusNode: focus)),
|
||||
),
|
||||
);
|
||||
focus.requestFocus();
|
||||
await tester.pump();
|
||||
focus.unfocus();
|
||||
await tester.pump();
|
||||
now = now.add(composerBlurGrace * 2);
|
||||
await _switchAway(tester);
|
||||
expect(focus.hasFocus, isFalse);
|
||||
|
||||
focus.requestFocus();
|
||||
await tester.pump();
|
||||
focus.unfocus();
|
||||
await tester.pump();
|
||||
now = now.add(composerBlurGrace ~/ 2);
|
||||
await _switchAway(tester);
|
||||
expect(focus.hasPrimaryFocus, isTrue);
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,190 @@
|
||||
import { createServer } from 'node:http';
|
||||
import { readFile, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
|
||||
import { spawn, execFile } from 'node:child_process';
|
||||
import { promisify } from 'node:util';
|
||||
import { once } from 'node:events';
|
||||
import { setTimeout as delay } from 'node:timers/promises';
|
||||
import { join, extname, resolve, sep } from 'node:path';
|
||||
import { tmpdir } from 'node:os';
|
||||
|
||||
// Real Chrome check that the composer regains focus (caret and selection
|
||||
// kept) when the browser window comes back, and stays unfocused when it was
|
||||
// not focused before. Window switching is reproduced by the same DOM events
|
||||
// the browser sends: the editing element's blur (relatedTarget null), then
|
||||
// window blur, later window focus.
|
||||
//
|
||||
// Usage (from app/), with the composer probe build of chat_composer_probe.mjs:
|
||||
// OPENCODE_ARTIFACT_DIR=<dir> node tool/composer_focus_restore_probe.mjs build/composer_probe_material
|
||||
//
|
||||
// The fixture is served over loopback only. Flutter paints text on a canvas, so
|
||||
// assertions read the semantics tree (aria-label/innerText) and the focused
|
||||
// editing element; captures are PNGs for visual inspection.
|
||||
|
||||
const artifactDir = process.env.OPENCODE_ARTIFACT_DIR;
|
||||
if (!artifactDir) throw new Error('Set OPENCODE_ARTIFACT_DIR for the captures');
|
||||
await mkdir(artifactDir, { recursive: true });
|
||||
const root = resolve(process.argv[2] ?? join(process.cwd(), 'build/composer_probe_material'));
|
||||
|
||||
const mime = {
|
||||
'.html': 'text/html',
|
||||
'.js': 'text/javascript',
|
||||
'.json': 'application/json',
|
||||
'.wasm': 'application/wasm',
|
||||
'.png': 'image/png',
|
||||
'.ico': 'image/x-icon',
|
||||
'.ttf': 'font/ttf',
|
||||
'.otf': 'font/otf',
|
||||
'.woff': 'font/woff',
|
||||
'.woff2': 'font/woff2',
|
||||
};
|
||||
const server = createServer(async (req, res) => {
|
||||
try {
|
||||
const path = resolve(root, '.' + decodeURIComponent(new URL(req.url, 'http://localhost').pathname));
|
||||
if (path !== root && !path.startsWith(root + sep)) return res.writeHead(403).end();
|
||||
const filePath = path === root || path.endsWith('/') ? join(path, 'index.html') : path;
|
||||
const file = await readFile(filePath);
|
||||
res.writeHead(200, { 'content-type': mime[extname(filePath)] ?? 'application/octet-stream' }).end(file);
|
||||
} catch {
|
||||
res.writeHead(404).end('not found');
|
||||
}
|
||||
});
|
||||
server.listen(0, '127.0.0.1');
|
||||
await once(server, 'listening');
|
||||
const port = server.address().port;
|
||||
const profile = await mkdtemp(join(tmpdir(), 'chat-composer-chrome-'));
|
||||
const chrome = spawn('/Applications/Google Chrome.app/Contents/MacOS/Google Chrome', [
|
||||
'--headless=new', '--no-first-run', '--no-default-browser-check', '--disable-gpu',
|
||||
'--remote-debugging-port=0', `--user-data-dir=${profile}`, 'about:blank',
|
||||
], { stdio: ['ignore', 'ignore', 'pipe'] });
|
||||
let stderr = '';
|
||||
chrome.stderr.on('data', data => { stderr += data; });
|
||||
|
||||
let ws;
|
||||
try {
|
||||
const waitFor = async (fn, what) => {
|
||||
for (let i = 0; i < 120; i++) { const value = await fn(); if (value) return value; await delay(100); }
|
||||
throw new Error(`Timed out waiting for ${what}`);
|
||||
};
|
||||
const endpoint = await waitFor(
|
||||
() => stderr.match(/DevTools listening on (ws:\/\/[^\s]+)/)?.[1],
|
||||
'Chrome DevTools',
|
||||
);
|
||||
ws = new WebSocket(endpoint);
|
||||
await once(ws, 'open');
|
||||
let id = 0;
|
||||
const pending = new Map();
|
||||
ws.addEventListener('message', event => {
|
||||
const msg = JSON.parse(event.data);
|
||||
if (msg.method?.includes('detached') || msg.method?.includes('crashed')) {
|
||||
console.error('CDP event', JSON.stringify(msg));
|
||||
}
|
||||
if (msg.method === 'Runtime.exceptionThrown') {
|
||||
console.error('PAGE EXCEPTION', JSON.stringify(msg.params?.exceptionDetails?.exception?.description ?? msg.params?.exceptionDetails?.text));
|
||||
}
|
||||
if (msg.id && pending.has(msg.id)) { pending.get(msg.id)(msg); pending.delete(msg.id); }
|
||||
});
|
||||
const send = (method, params = {}, sessionId) => new Promise(resolve => {
|
||||
const callId = ++id;
|
||||
pending.set(callId, resolve);
|
||||
ws.send(JSON.stringify({ id: callId, method, params, ...(sessionId ? { sessionId } : {}) }));
|
||||
});
|
||||
const created = await send('Target.createTarget', { url: 'about:blank' });
|
||||
if (!created.result) throw new Error(`Target creation failed: ${JSON.stringify(created)}`);
|
||||
const session = (await send('Target.attachToTarget', { targetId: created.result.targetId, flatten: true })).result.sessionId;
|
||||
await send('Page.enable', {}, session);
|
||||
await send('Runtime.enable', {}, session);
|
||||
const navigation = await send('Page.navigate', { url: `http://127.0.0.1:${port}/` }, session);
|
||||
if (navigation.error || navigation.result?.errorText) throw new Error(JSON.stringify(navigation));
|
||||
const evaluate = async expression => {
|
||||
const response = await send('Runtime.evaluate', { expression, returnByValue: true, awaitPromise: true }, session);
|
||||
if (response.error) throw new Error(`Runtime.evaluate failed: ${JSON.stringify(response)}`);
|
||||
return response.result?.result?.value;
|
||||
};
|
||||
// Wait for the app, but leave semantics off: that is the operator's normal
|
||||
// mode, where the engine's own editing element (and its blur handling)
|
||||
// backs the field.
|
||||
for (let i = 0; i < 120; i++) {
|
||||
if (await evaluate("Boolean(document.querySelector('flt-semantics-placeholder'))")) break;
|
||||
await delay(100);
|
||||
}
|
||||
await delay(1800);
|
||||
const click = async (x, y) => {
|
||||
for (const type of ['mousePressed', 'mouseReleased']) {
|
||||
await send('Input.dispatchMouseEvent', { type, x, y, button: 'left', clickCount: 1 }, session);
|
||||
}
|
||||
};
|
||||
// The composer sits at the bottom; click upward until an editing element
|
||||
// takes focus.
|
||||
const focusField = async () => {
|
||||
for (let y = 790; y > 500; y -= 10) {
|
||||
await click(640, y);
|
||||
await delay(150);
|
||||
if ((await state()).editing) return y;
|
||||
}
|
||||
throw new Error('No click focused the composer');
|
||||
};
|
||||
const type = async text => { await send('Input.insertText', { text }, session); await delay(250); };
|
||||
const setSize = async (width, height, scale = 1) => {
|
||||
await send('Emulation.setDeviceMetricsOverride', {
|
||||
width, height, deviceScaleFactor: scale, mobile: width < 600,
|
||||
}, session);
|
||||
await delay(400);
|
||||
};
|
||||
const state = () => evaluate(`(() => {
|
||||
const a = document.activeElement;
|
||||
// The composer is the fixture's only text field, so a focused editing
|
||||
// element (engine textarea or semantics textarea) is the composer.
|
||||
const editing = Boolean(a && (a.tagName === 'TEXTAREA' || a.tagName === 'INPUT'));
|
||||
return { editing, value: editing ? a.value : null,
|
||||
start: editing ? a.selectionStart : null, end: editing ? a.selectionEnd : null };
|
||||
})()`);
|
||||
const switchWindow = async () => {
|
||||
// Two evaluations, as two event dispatches in the browser: microtasks
|
||||
// (the framework handling the engine's closed text connection) run in
|
||||
// between, so Flutter has already unfocused the field before the window
|
||||
// blur reaches it. One script doing both would hide that.
|
||||
await evaluate('document.activeElement?.blur()');
|
||||
await evaluate("window.dispatchEvent(new FocusEvent('blur'))");
|
||||
await delay(600);
|
||||
const away = await state();
|
||||
await evaluate("window.dispatchEvent(new FocusEvent('focus'))");
|
||||
await delay(800);
|
||||
return { away, back: await state() };
|
||||
};
|
||||
const failures = [];
|
||||
const check = (ok, what) => { console.log(`${ok ? 'PASS' : 'FAIL'} ${what}`); if (!ok) failures.push(what); };
|
||||
|
||||
await setSize(1280, 800);
|
||||
console.log('composer at y', await focusField());
|
||||
await type('hello world');
|
||||
await evaluate(`(() => { const a = document.activeElement; a.setSelectionRange(2, 5); a.dispatchEvent(new Event('selectionchange')); document.dispatchEvent(new Event('selectionchange')); })()`);
|
||||
await delay(400);
|
||||
const before = await state();
|
||||
console.log('before', JSON.stringify(before));
|
||||
const focused = await switchWindow();
|
||||
console.log('focused case', JSON.stringify(focused));
|
||||
check(!focused.away.editing, 'composer loses DOM focus while the window is away');
|
||||
check(focused.back.editing && focused.back.value === 'hello world', 'composer regains focus with its text');
|
||||
check(focused.back.start === before.start && focused.back.end === before.end, `selection kept (${before.start}-${before.end})`);
|
||||
await send('Page.captureScreenshot', { format: 'png' }, session).then(r =>
|
||||
writeFile(join(artifactDir, 'focus-restored.png'), Buffer.from(r.result.data, 'base64')));
|
||||
|
||||
// Control: composer not focused when the window leaves.
|
||||
// The operator clicks the transcript (tap outside unfocuses the field),
|
||||
// then switches windows a moment later.
|
||||
await click(640, 200);
|
||||
await delay(1000);
|
||||
console.log('after click away', JSON.stringify(await state()));
|
||||
const unfocused = await switchWindow();
|
||||
console.log('unfocused case', JSON.stringify(unfocused));
|
||||
check(!unfocused.back.editing, 'composer stays unfocused when it was not focused');
|
||||
|
||||
if (failures.length) throw new Error(`Failed: ${failures.join('; ')}`);
|
||||
console.log('composer focus restore probe passed');
|
||||
} finally {
|
||||
ws?.close();
|
||||
chrome.kill('SIGTERM');
|
||||
await Promise.race([once(chrome, 'exit'), delay(3000)]);
|
||||
server.close();
|
||||
await rm(profile, { recursive: true, force: true });
|
||||
}
|
||||
Reference in New Issue
Block a user