fix(app): switch language atomically and bound camera, sound preview and lab browsing (#62121)

This commit is contained in:
Luke Parker
2026-11-05 09:56:16 -06:00
committed by GitHub
Unverified
parent 47cace689a
commit b903ae5cc9
17 changed files with 1173 additions and 168 deletions
@@ -96,6 +96,43 @@ test("a settings page survives refresh", async ({ page }) => {
await expect(page).toHaveURL("/settings?tab=appearance")
})
// The Arabic dictionary chunks: built (`_assets/ar-<hash>.js`) and dev (`.../i18n/ar.ts`), for the app and the UI.
const arabic = /\/(?:_assets\/ar-[\w-]+\.js|i18n\/ar\.ts)(?:\?|$)/
async function pickArabic(page: Page) {
const { settings } = await open(page)
await settings.locator('[data-action="settings-language"]').click()
await page.getByRole("listbox").getByRole("option", { name: "العربية", exact: true }).click()
return settings
}
test("a language switch keeps settings on screen and flips direction only with the new strings", async ({ page }) => {
const chunks = await holdRoute(page, arabic)
const html = page.locator("html")
const settings = await pickArabic(page)
await chunks.arrived
await expect(settings.getByText("Language", { exact: true })).toBeVisible()
await expect(html).toHaveAttribute("dir", "ltr")
await expect(html).toHaveAttribute("lang", "en")
chunks.release()
await expect(settings.getByText("اللغة", { exact: true })).toBeVisible()
await expect(html).toHaveAttribute("dir", "rtl")
await expect(html).toHaveAttribute("lang", "ar")
})
test("a language whose chunk fails to load keeps English and says so", async ({ page }) => {
await page.route(arabic, (route) => route.abort("failed"))
const settings = await pickArabic(page)
await expect(page.getByText("Failed to load العربية", { exact: true })).toBeVisible()
await expect(settings.getByText("Language", { exact: true })).toBeVisible()
await expect(page.locator("html")).toHaveAttribute("dir", "ltr")
await expect(settings.locator('[data-action="settings-language"]')).toContainText("English")
})
test("Questions settings default independently of old Permissions settings and survive reload", async ({ page }) => {
const { settings } = await open(page, {
seed: {
+25 -16
View File
@@ -49,8 +49,12 @@ import {
} from "./catalog"
import {
createLabStageState,
INITIAL_LAB_BROWSE_STATE,
labStageIndex,
selectShouldToggleFolder,
transitionLabBrowse,
transitionLabStage,
type LabBrowseEvent,
type LabStageEffect,
type LabStageEvent,
} from "./machine"
@@ -124,18 +128,20 @@ export default function ComponentsLab() {
let palette: CommandPalette | undefined
let toggle: ((id: string) => void) | undefined
let focusTree: ((id?: string) => void) | undefined
// While browsing the tree by keys, a story that focuses something as it mounts (a dialog, a field) would take the
// keys away. A press or Tab anywhere ends browsing; a few returns at most, so a story that traps focus still wins.
let browsing = 0
// The key behind the latest selection; none for a press.
let key: string | undefined
let browse = INITIAL_LAB_BROWSE_STATE
const dispatchBrowse = (event: LabBrowseEvent) => {
const next = transitionLabBrowse(browse, event)
browse = next.state
next.effects.forEach(() => focusTree?.(params.story))
}
const entries = () => catalog()?.entries ?? []
const grid = () => params.view === "grid"
const selected = createMemo(() => (grid() ? undefined : entries().find((entry) => entry.file === params.story)))
const open = (file: string) => {
browsing = stories.contains(document.activeElement) ? 3 : 0
dispatchBrowse({ type: "story.opened", fromTree: stories.contains(document.activeElement) })
setParams({ story: file, view: undefined })
}
@@ -229,7 +235,7 @@ export default function ComponentsLab() {
onSelect={(_, primary) => {
if (!primary?.startsWith("folder:")) return primary && open(primary)
if (key === undefined || key === " ") toggle?.(primary)
if (selectShouldToggleFolder(browse)) toggle?.(primary)
}}
onActivate={(id) => (id.startsWith("folder:") ? toggle?.(id) : open(id))}
/>
@@ -261,20 +267,23 @@ export default function ComponentsLab() {
</Show>
))
makeEventListener(window, "pointerdown", () => ((browsing = 0), (key = undefined)), { capture: true })
const inTree = (event: Event) => event.target instanceof Node && stories.contains(event.target)
makeEventListener(window, "pointerdown", (event) => dispatchBrowse({ type: "pointer.down", inTree: inTree(event) }), {
capture: true,
})
// Bubbling, so the tree's own pointerup (which completes a press on a selected row) selects first.
makeEventListener(window, "pointerup", () => dispatchBrowse({ type: "pointer.ended" }))
makeEventListener(window, "pointercancel", () => dispatchBrowse({ type: "pointer.ended" }))
makeEventListener(
window,
"keydown",
(event) => {
key = event.key
if (event.key === "Tab") browsing = 0
},
(event) => dispatchBrowse({ type: "key.down", key: event.key, inTree: inTree(event) }),
{ capture: true },
)
makeEventListener(stage, "focusin", () => {
if (browsing-- > 0) focusTree?.(params.story)
})
makeEventListener(window, "keyup", () => dispatchBrowse({ type: "key.ended" }))
makeEventListener(window, "blur", () => dispatchBrowse({ type: "window.blurred" }))
makeEventListener(stage, "focusin", () => dispatchBrowse({ type: "stage.focused" }))
let element!: HTMLDivElement
@@ -1,13 +1,91 @@
import { expect, test } from "bun:test"
import {
createLabStageState,
INITIAL_LAB_BROWSE_STATE,
labStageIndex,
selectShouldToggleFolder,
transitionLabBrowse,
transitionLabStage,
type LabBrowseEvent,
type LabBrowseState,
type LabStageEvent,
type LabStageState,
type LabStageTransition,
} from "./machine"
/** Each event's effects from `state`, and the state after the last. */
const browse = (state: LabBrowseState, ...events: LabBrowseEvent[]) =>
events.reduce<{ state: LabBrowseState; effects: string[] }>(
(current, event) => {
const next = transitionLabBrowse(current.state, event)
return { state: next.state, effects: [...current.effects, ...next.effects.map((effect) => effect.type)] }
},
{ state, effects: [] },
)
test("focus moving inside the stage at rest stays at rest", () => {
const focused = browse(INITIAL_LAB_BROWSE_STATE, { type: "stage.focused" }, { type: "stage.focused" })
expect(focused.state).toBe(INITIAL_LAB_BROWSE_STATE)
expect(focused.effects).toEqual([])
// Many focus moves later, a story opened from the tree still gets exactly three returns.
const opened = browse(
focused.state,
{ type: "story.opened", fromTree: true },
...Array.from({ length: 4 }, () => ({ type: "stage.focused" }) as const),
)
expect(opened.effects).toEqual(["focus.tree", "focus.tree", "focus.tree"])
expect(opened.state).toBe(INITIAL_LAB_BROWSE_STATE)
})
test.each([{ type: "key.ended" }, { type: "window.blurred" }] as const)(
"a Space press in the tree no longer toggles folders after $type",
(end) => {
const pressed = browse(INITIAL_LAB_BROWSE_STATE, { type: "key.down", key: " ", inTree: true })
expect(selectShouldToggleFolder(pressed.state)).toBe(true)
expect(selectShouldToggleFolder(browse(pressed.state, end).state)).toBe(false)
},
)
test("a Space press outside the tree and arrow keys in it never toggle folders", () => {
expect(selectShouldToggleFolder(INITIAL_LAB_BROWSE_STATE)).toBe(false)
expect(browse(INITIAL_LAB_BROWSE_STATE, { type: "key.down", key: " ", inTree: false }).state).toBe(
INITIAL_LAB_BROWSE_STATE,
)
expect(
selectShouldToggleFolder(
browse(
INITIAL_LAB_BROWSE_STATE,
{ type: "key.down", key: " ", inTree: true },
{ type: "key.down", key: "ArrowDown", inTree: true },
).state,
),
).toBe(false)
})
test("a click in the tree toggles folders until the press ends", () => {
const pressed = browse(INITIAL_LAB_BROWSE_STATE, { type: "pointer.down", inTree: true })
expect(selectShouldToggleFolder(pressed.state)).toBe(true)
expect(browse(pressed.state, { type: "pointer.ended" }).state).toBe(INITIAL_LAB_BROWSE_STATE)
})
test.each([
{ type: "key.down", key: "Tab", inTree: true },
{ type: "pointer.down", inTree: false },
] as const)("$type ends browsing before the stage takes focus", (exit) => {
const ended = browse(INITIAL_LAB_BROWSE_STATE, { type: "story.opened", fromTree: true }, exit, {
type: "stage.focused",
})
expect(ended.effects).toEqual([])
expect(ended.state).toBe(INITIAL_LAB_BROWSE_STATE)
})
const names = ["Closed", "Opening", "Open"]
/** The last transition of `events` from `state`. */
@@ -139,3 +139,91 @@ function show(
function unchanged(state: LabStageState): LabStageTransition {
return { state, effects: [] }
}
/**
* How a press reached the tree. A folder opens and closes only by a click or Space in the tree, so moving by arrows
* (which selects as it goes) or a selection from elsewhere leaves it as it is.
*/
export type LabTreeGesture = "none" | "pointer" | "space"
/**
* While browsing the tree by keys, a story that focuses something as it mounts (a dialog, a field) would take the
* keys away. A press or Tab anywhere ends browsing; a few returns at most, so a story that traps focus still wins.
*/
export type LabBrowseState =
| { readonly status: "idle"; readonly gesture: LabTreeGesture }
| { readonly status: "browsing"; readonly redirects: 1 | 2 | 3; readonly gesture: LabTreeGesture }
export type LabBrowseEvent =
| { readonly type: "pointer.down"; readonly inTree: boolean }
| { readonly type: "pointer.ended" }
| { readonly type: "key.down"; readonly key: string; readonly inTree: boolean }
| { readonly type: "key.ended" }
| { readonly type: "window.blurred" }
| { readonly type: "story.opened"; readonly fromTree: boolean }
/** Focus moved into the stage. */
| { readonly type: "stage.focused" }
export type LabBrowseEffect = { readonly type: "focus.tree" }
export type LabBrowseTransition = {
readonly state: LabBrowseState
readonly effects: readonly LabBrowseEffect[]
}
export const INITIAL_LAB_BROWSE_STATE: LabBrowseState = Object.freeze({ status: "idle", gesture: "none" })
export function transitionLabBrowse(state: LabBrowseState, event: LabBrowseEvent): LabBrowseTransition {
if (event.type === "pointer.down") {
const gesture = event.inTree ? "pointer" : "none"
return { state: state.status === "idle" && state.gesture === gesture ? state : idle(gesture), effects: [] }
}
if (event.type === "key.down") {
if (event.key === "Tab") return { state: INITIAL_LAB_BROWSE_STATE, effects: [] }
return { state: withGesture(state, event.key === " " && event.inTree ? "space" : "none"), effects: [] }
}
if (event.type === "pointer.ended")
return { state: state.gesture === "pointer" ? withGesture(state, "none") : state, effects: [] }
if (event.type === "key.ended")
return { state: state.gesture === "space" ? withGesture(state, "none") : state, effects: [] }
if (event.type === "window.blurred") return { state: INITIAL_LAB_BROWSE_STATE, effects: [] }
if (event.type === "story.opened") {
if (!event.fromTree) return { state: idle(state.gesture), effects: [] }
return { state: { status: "browsing", redirects: 3, gesture: state.gesture }, effects: [] }
}
if (state.status === "idle") return { state, effects: [] }
return {
state:
state.redirects === 1
? idle(state.gesture)
: { status: "browsing", redirects: state.redirects === 3 ? 2 : 1, gesture: state.gesture },
effects: [{ type: "focus.tree" }],
}
}
/** A selection of a folder toggles it only while a click or Space in the tree caused it. */
export function selectShouldToggleFolder(state: LabBrowseState) {
return state.gesture !== "none"
}
function idle(gesture: LabTreeGesture): LabBrowseState {
return gesture === "none" ? INITIAL_LAB_BROWSE_STATE : { status: "idle", gesture }
}
function withGesture(state: LabBrowseState, gesture: LabTreeGesture): LabBrowseState {
if (state.gesture === gesture) return state
if (state.status === "idle") return idle(gesture)
return { ...state, gesture }
}
+1
View File
@@ -491,6 +491,7 @@ export const dict = {
"toast.permissions.autoaccept.off.description": "Permission requests will require approval",
"toast.file.loadFailed.title": "Failed to load file",
"toast.language.loadFailed.title": "Failed to load {{language}}",
"toast.file.listFailed.title": "Failed to list files",
"toast.context.noLineSelection.title": "No line selection",
+86 -12
View File
@@ -1,7 +1,8 @@
import { createEffect, createMemo, createResource, type JSX } from "solid-js"
import { batch, createEffect, createMemo, createSignal, on, onCleanup, untrack, type JSX } from "solid-js"
import { createStore } from "solid-js/store"
import { Option, Schema, SchemaGetter } from "effect"
import { createSimpleContext } from "@opencode/ui/context"
import { showToast } from "@opencode/ui/toast"
import {
I18nProvider,
type UiI18n,
@@ -25,6 +26,14 @@ import {
type DesktopNativeBundle,
type DesktopNativeLocale,
} from "@/runtime/i18n/desktop-native"
import {
createLanguageState,
selectDictionary,
selectLocale,
transitionLanguage,
type LanguageEffect,
type LanguageEvent,
} from "@/runtime/i18n/machine"
export type Locale = DesktopNativeLocale
@@ -242,7 +251,64 @@ export const { use: useLanguage, provider: LanguageProvider } = createSimpleCont
const initial = props.locale ?? readStoredLocale() ?? detectLocale()
const [store, setStore, _, ready] = persisted(Persist.global("language"), languageSchema, { locale: initial })
const locale = createMemo(() => store.locale)
const stored = untrack(() => store.locale)
const boot = createLanguageState({
initial: stored,
cached: dicts.get(stored),
fallbackLocale: "en",
fallbackDictionary: base,
})
const [machine, setMachine] = createSignal(boot.state)
let timer: ReturnType<typeof setTimeout> | undefined
const dispatch = (event: LanguageEvent<Dictionary>) =>
batch(() => {
const prev = untrack(machine)
const next = transitionLanguage(prev, event)
if (next.state !== prev) setMachine(next.state)
next.effects.forEach(run)
})
const run = (effect: LanguageEffect) => {
if (effect.type === "load")
return void Promise.try(() => loadDict(effect.locale)).then(
(dictionary) => dispatch({ type: "load.succeeded", attempt: effect.attempt, dictionary }),
() => dispatch({ type: "load.failed", attempt: effect.attempt }),
)
if (effect.type === "timer.start") {
clearTimeout(timer)
timer = setTimeout(() => dispatch({ type: "load.timed-out", attempt: effect.attempt }), effect.timeoutMs)
return
}
if (effect.type === "timer.stop") {
clearTimeout(timer)
timer = undefined
return
}
if (effect.type === "persist") {
if (untrack(() => store.locale) !== effect.locale) setStore("locale", effect.locale)
return
}
showToast({
variant: "error",
title: t("toast.language.loadFailed.title", { language: label(effect.locale) }),
})
}
// The committed pair: every reader switches only once the dictionary for the new locale is in hand, so `t()`
// never suspends and the direction never flips ahead of the strings.
const locale = createMemo(() => selectLocale(machine()))
const dictionary = createMemo(() => selectDictionary(machine()))
const intl = createMemo(() => INTL[locale()])
// SAFETY: widens the initial `undefined` so a direction can be stored later.
const [layout, setLayout] = createStore({ direction: undefined as Direction | undefined })
@@ -255,15 +321,11 @@ export const { use: useLanguage, provider: LanguageProvider } = createSimpleCont
return layout.direction === "rtl" ? "ar" : "en"
})
const [dictionary] = createResource(locale, loadDict, {
initialValue: dicts.get(initial) ?? base,
})
const t = <Key extends Extract<keyof Dictionary, string>>(
key: TranslationKey<Key>,
params?: Record<string, string | number | boolean>,
) => {
const template: string | undefined = (dictionary() ?? base)[key]
const template: string | undefined = dictionary()[key]
// A key outside the dictionary translates to nothing, as it did with the package translator.
return template === undefined ? template : resolveTemplate(template, params)
@@ -275,7 +337,7 @@ export const { use: useLanguage, provider: LanguageProvider } = createSimpleCont
params?: Record<string, string | number | boolean>,
) => {
// SAFETY: every dictionary value is a string (`language.test.ts`).
const current = (dictionary.loading ? base : (dictionary() ?? base)) as Record<string, string>
const current = dictionary() as Record<string, string>
const candidate = `${key}.${category}`
const fallback = `${key}.other`
@@ -306,7 +368,7 @@ export const { use: useLanguage, provider: LanguageProvider } = createSimpleCont
params: Record<string, JSX.Element>,
) => {
// SAFETY: every dictionary value is a string (`language.test.ts`).
const current = (dictionary.loading ? base : (dictionary() ?? base)) as Record<string, string>
const current = dictionary() as Record<string, string>
return richTemplateParts(current[key] ?? key, params)
}
@@ -337,15 +399,26 @@ export const { use: useLanguage, provider: LanguageProvider } = createSimpleCont
})
createEffect(() => {
if (!props.onNativeTranslations || dictionary.loading) return
if (!props.onNativeTranslations) return
const current = dictionary()
if (!current) return
props.onNativeTranslations(
createDesktopNativeBundle(locale(), (key) => current[key] ?? DESKTOP_NATIVE_ENGLISH[key]),
)
})
// Storage hydrating after mount, or another window picking a language.
createEffect(
on(
() => store.locale,
(next) => dispatch({ type: "locale.synced", locale: next, cached: dicts.get(next) }),
{ defer: true },
),
)
onCleanup(() => dispatch({ type: "disposed" }))
boot.effects.forEach(run)
return {
ready,
locale,
@@ -363,7 +436,8 @@ export const { use: useLanguage, provider: LanguageProvider } = createSimpleCont
rich,
list,
setLocale(next: Locale) {
setStore("locale", normalizeLocale(next))
const target = normalizeLocale(next)
dispatch({ type: "locale.requested", locale: target, cached: dicts.get(target) })
},
setDirection(next: Direction) {
setLayout("direction", next === localeDirection(locale()) ? undefined : next)
@@ -0,0 +1,148 @@
import { describe, expect, test } from "bun:test"
import {
createLanguageState,
LOCALE_LOAD_TIMEOUT_MS,
selectDictionary,
selectLocale,
transitionLanguage,
type LanguageEffect,
type LanguageEvent,
type LanguageState,
} from "./machine"
type Dict = { readonly hello: string }
const en: Dict = { hello: "Hello" }
const de: Dict = { hello: "Hallo" }
const ar: Dict = { hello: "مرحبا" }
const readyOn = (locale: "en" | "de", dictionary: Dict) =>
createLanguageState({ initial: locale, cached: dictionary, fallbackLocale: "en", fallbackDictionary: en }).state
function replay(state: LanguageState<Dict>, events: readonly LanguageEvent<Dict>[]) {
return events.reduce<{ state: LanguageState<Dict>; effects: LanguageEffect[] }>(
(result, event) => {
const next = transitionLanguage(result.state, event)
return { state: next.state, effects: [...result.effects, ...next.effects] }
},
{ state, effects: [] },
)
}
const shown = (state: LanguageState<Dict>) => ({ locale: selectLocale(state), dictionary: selectDictionary(state) })
describe("language machine", () => {
test("a failed chunk for a picked language keeps the current one and says so", () => {
const loading = transitionLanguage(readyOn("en", en), { type: "locale.requested", locale: "ar", cached: undefined })
expect(loading.effects).toEqual([
{ type: "load", attempt: 1, locale: "ar" },
{ type: "timer.start", attempt: 1, timeoutMs: LOCALE_LOAD_TIMEOUT_MS },
])
expect(shown(loading.state)).toEqual({ locale: "en", dictionary: en })
const failed = transitionLanguage(loading.state, { type: "load.failed", attempt: 1 })
expect(failed.state).toEqual({ status: "ready", issued: 1, locale: "en", dictionary: en })
expect(failed.effects).toEqual([{ type: "timer.stop" }, { type: "notify.error", locale: "ar" }])
})
test("a stored language whose chunk fails at startup falls back to English quietly", () => {
const boot = createLanguageState<Dict>({
initial: "ja",
cached: undefined,
fallbackLocale: "en",
fallbackDictionary: en,
})
expect(shown(boot.state)).toEqual({ locale: "en", dictionary: en })
expect(boot.effects[0]).toEqual({ type: "load", attempt: 1, locale: "ja" })
const failed = transitionLanguage(boot.state, { type: "load.failed", attempt: 1 })
expect(shown(failed.state)).toEqual({ locale: "en", dictionary: en })
expect(failed.effects).toEqual([{ type: "timer.stop" }])
})
test("a switch keeps the previous language and direction until the new dictionary lands, then commits both", () => {
const loading = transitionLanguage(readyOn("de", de), { type: "locale.requested", locale: "ar", cached: undefined })
expect(shown(loading.state)).toEqual({ locale: "de", dictionary: de })
const loaded = transitionLanguage(loading.state, { type: "load.succeeded", attempt: 1, dictionary: ar })
expect(shown(loaded.state)).toEqual({ locale: "ar", dictionary: ar })
expect(loaded.effects).toEqual([{ type: "timer.stop" }, { type: "persist", locale: "ar" }])
})
test("a chunk that never answers times out back to the committed language", () => {
const result = replay(readyOn("en", en), [
{ type: "locale.requested", locale: "ar", cached: undefined },
{ type: "load.timed-out", attempt: 1 },
])
expect(shown(result.state)).toEqual({ locale: "en", dictionary: en })
expect(result.effects.slice(-2)).toEqual([{ type: "timer.stop" }, { type: "notify.error", locale: "ar" }])
})
test.each([
{ name: "another uncached language", next: { locale: "fr", cached: undefined }, shows: "en" },
{ name: "a cached language", next: { locale: "de", cached: de }, shows: "de" },
] as const)("picking $name ignores the earlier load's late result", (input) => {
const switched = replay(readyOn("en", en), [
{ type: "locale.requested", locale: "ar", cached: undefined },
{ type: "locale.requested", ...input.next },
])
expect(switched.effects).toContainEqual({ type: "timer.stop" })
const late = transitionLanguage(switched.state, { type: "load.succeeded", attempt: 1, dictionary: ar })
expect(late).toEqual({ state: switched.state, effects: [] })
expect(selectLocale(late.state)).toBe(input.shows)
})
test("storage syncing during the user's own pick does not replace it", () => {
const loading = transitionLanguage(readyOn("en", en), { type: "locale.requested", locale: "ar", cached: undefined })
expect(transitionLanguage(loading.state, { type: "locale.synced", locale: "de", cached: de })).toEqual({
state: loading.state,
effects: [],
})
})
test("a synced language loads without storing or announcing anything", () => {
const result = replay(readyOn("en", en), [
{ type: "locale.synced", locale: "ar", cached: undefined },
{ type: "load.failed", attempt: 1 },
])
expect(result.effects.filter((effect) => effect.type === "persist" || effect.type === "notify.error")).toEqual([])
})
test("picking the language that is already showing stores it without reloading", () => {
const state = readyOn("en", en)
expect(transitionLanguage(state, { type: "locale.requested", locale: "en", cached: en })).toEqual({
state,
effects: [{ type: "persist", locale: "en" }],
})
})
test("disposal stops the load timer, keeps the dictionary readable and ignores later results", () => {
const disposed = replay(readyOn("en", en), [
{ type: "locale.requested", locale: "ar", cached: undefined },
{ type: "disposed" },
])
expect(disposed.effects.at(-1)).toEqual({ type: "timer.stop" })
expect(shown(disposed.state)).toEqual({ locale: "en", dictionary: en })
expect(transitionLanguage(disposed.state, { type: "load.succeeded", attempt: 1, dictionary: ar })).toEqual({
state: disposed.state,
effects: [],
})
})
})
+164
View File
@@ -0,0 +1,164 @@
import type { DesktopNativeLocale } from "./desktop-native"
/** A dynamic `import()` can hang on a stalled network; past this the switch gives up and keeps the current language. */
export const LOCALE_LOAD_TIMEOUT_MS = 10_000
/**
* `locale` and `dictionary` are always the committed pair every reader shows. A load keeps them until its dictionary
* arrives, so the strings, plural rules, `lang`/`dir` and the stored choice switch together, never one ahead.
*/
export type LanguageState<Dict> =
| {
readonly status: "ready"
readonly issued: number
readonly locale: DesktopNativeLocale
readonly dictionary: Dict
}
| {
readonly status: "loading"
readonly issued: number
readonly attempt: number
readonly locale: DesktopNativeLocale
readonly dictionary: Dict
/** The locale whose dictionary is loading. */
readonly target: DesktopNativeLocale
/** The user chose it: success stores the choice and failure tells them. A synced load does neither. */
readonly persist: boolean
}
| { readonly status: "disposed"; readonly locale: DesktopNativeLocale; readonly dictionary: Dict }
export type LanguageEvent<Dict> =
/** The user picked a language. `cached` is its dictionary when it already loaded. */
| { readonly type: "locale.requested"; readonly locale: DesktopNativeLocale; readonly cached: Dict | undefined }
/** The stored choice changed under us: storage hydrated, or another window picked a language. */
| { readonly type: "locale.synced"; readonly locale: DesktopNativeLocale; readonly cached: Dict | undefined }
| { readonly type: "load.succeeded"; readonly attempt: number; readonly dictionary: Dict }
| { readonly type: "load.failed"; readonly attempt: number }
| { readonly type: "load.timed-out"; readonly attempt: number }
| { readonly type: "disposed" }
export type LanguageEffect =
| { readonly type: "load"; readonly attempt: number; readonly locale: DesktopNativeLocale }
| { readonly type: "timer.start"; readonly attempt: number; readonly timeoutMs: number }
| { readonly type: "timer.stop" }
/** Store the committed choice. */
| { readonly type: "persist"; readonly locale: DesktopNativeLocale }
| { readonly type: "notify.error"; readonly locale: DesktopNativeLocale }
export type LanguageTransition<Dict> = {
readonly state: LanguageState<Dict>
readonly effects: readonly LanguageEffect[]
}
/** Starts on `initial` when its dictionary is cached, else on the fallback while `initial` loads. */
export function createLanguageState<Dict>(input: {
readonly initial: DesktopNativeLocale
readonly cached: Dict | undefined
readonly fallbackLocale: DesktopNativeLocale
readonly fallbackDictionary: Dict
}): LanguageTransition<Dict> {
if (input.cached !== undefined)
return { state: { status: "ready", issued: 0, locale: input.initial, dictionary: input.cached }, effects: [] }
return load(
{ status: "ready", issued: 0, locale: input.fallbackLocale, dictionary: input.fallbackDictionary },
input.initial,
false,
)
}
export function transitionLanguage<Dict>(
state: LanguageState<Dict>,
event: LanguageEvent<Dict>,
): LanguageTransition<Dict> {
if (state.status === "disposed") return { state, effects: [] }
const stop = state.status === "loading" ? [STOP] : []
if (event.type === "disposed")
return { state: { status: "disposed", locale: state.locale, dictionary: state.dictionary }, effects: stop }
if (event.type === "locale.requested") {
const persist = { type: "persist", locale: event.locale } as const
// The stored choice can differ from the committed one after a failed load at startup, so it is written again.
if (state.status === "ready" && state.locale === event.locale) return { state, effects: [persist] }
if (event.cached !== undefined)
return { state: ready(state, event.locale, event.cached), effects: [...stop, persist] }
if (state.status === "loading" && state.target === event.locale)
return { state: state.persist ? state : { ...state, persist: true }, effects: [] }
return load(state, event.locale, true)
}
if (event.type === "locale.synced") {
// The user's own pick wins over the stored value it is about to replace.
if (state.status === "loading" && state.persist) return { state, effects: [] }
if (state.status === "ready" && state.locale === event.locale) return { state, effects: [] }
if (event.cached !== undefined) return { state: ready(state, event.locale, event.cached), effects: stop }
if (state.status === "loading" && state.target === event.locale) return { state, effects: [] }
return load(state, event.locale, false)
}
if (state.status !== "loading" || event.attempt !== state.attempt) return { state, effects: [] }
if (event.type === "load.succeeded")
return {
state: ready(state, state.target, event.dictionary),
effects: state.persist ? [STOP, { type: "persist", locale: state.target }] : [STOP],
}
return {
state: ready(state, state.locale, state.dictionary),
effects: state.persist ? [STOP, { type: "notify.error", locale: state.target }] : [STOP],
}
}
export function selectLocale<Dict>(state: LanguageState<Dict>) {
return state.locale
}
export function selectDictionary<Dict>(state: LanguageState<Dict>) {
return state.dictionary
}
const STOP = { type: "timer.stop" } as const
function ready<Dict>(
state: Exclude<LanguageState<Dict>, { status: "disposed" }>,
locale: DesktopNativeLocale,
dictionary: Dict,
): LanguageState<Dict> {
return { status: "ready", issued: state.issued, locale, dictionary }
}
function load<Dict>(
state: Exclude<LanguageState<Dict>, { status: "disposed" }>,
target: DesktopNativeLocale,
persist: boolean,
): LanguageTransition<Dict> {
const attempt = state.issued + 1
return {
state: {
status: "loading",
issued: attempt,
attempt,
locale: state.locale,
dictionary: state.dictionary,
target,
persist,
},
effects: [
...(state.status === "loading" ? [STOP] : []),
{ type: "load", attempt, locale: target },
{ type: "timer.start", attempt, timeoutMs: LOCALE_LOAD_TIMEOUT_MS },
],
}
}
@@ -1,33 +0,0 @@
import { createResource } from "solid-js"
import { usePlatform } from "@/runtime/platform/platform"
export function createCameraAvailability() {
const platform = usePlatform()
const supported = platform.platform === "web" && window.isSecureContext && !!navigator.mediaDevices?.getUserMedia
const [available, actions] = createResource(
async () => {
if (!supported || !navigator.mediaDevices.enumerateDevices) return false
const denied = await navigator.permissions?.query({ name: "camera" }).then(
(permission) => permission.state === "denied",
() => false,
)
if (denied) return false
return navigator.mediaDevices.enumerateDevices().then(
(devices) => devices.some((device) => device.kind === "videoinput"),
() => false,
)
},
{ initialValue: false },
)
return { supported, available, refetch: actions.refetch }
}
// Pages served over plain HTTP cannot open the camera. QR codes carry JSON, not a link, so the pasted link is the way in.
export function cameraHint() {
return window.isSecureContext ? "server.connect.camera.unavailable" : "server.connect.camera.native"
}
+47 -2
View File
@@ -5,9 +5,10 @@ import { useCheckServerHealth } from "@/runtime/server/health"
import { ServerConnection, useServers } from "@/runtime/server/registry"
import { replaceServerConnection } from "@/servers/registry/management"
import {
createServerConnectState,
selectServerConnectView,
startServerConnect,
transitionServerConnect,
type ServerCameraSupport,
type ServerConnectEffect,
type ServerConnectEvent,
type ServerConnectTarget,
@@ -36,8 +37,10 @@ export function createServerConnectController(options: ServerConnectControllerOp
const check = useCheckServerHealth()
// Shared with the scanner, so a retry after a failed check reuses the token of a spent one-time code.
const redeem = useRedeemPairing()
const [machine, setMachine] = createSignal(createServerConnectState(options.target))
const initial = startServerConnect(options.target, cameraSupport(platform.platform))
const [machine, setMachine] = createSignal(initial.state)
let timer: ReturnType<typeof setTimeout> | undefined
let cameraTimer: ReturnType<typeof setTimeout> | undefined
const dispatch = (event: ServerConnectEvent) => {
const prev = untrack(machine)
@@ -62,6 +65,24 @@ export function createServerConnectController(options: ServerConnectControllerOp
return
}
if (effect.type === "camera.probe") {
clearTimeout(cameraTimer)
cameraTimer = setTimeout(() => dispatch({ type: "camera.timed-out", attempt: effect.attempt }), effect.timeoutMs)
void Promise.try(probeCamera).then(
(available) => dispatch({ type: "camera.settled", attempt: effect.attempt, available }),
() => dispatch({ type: "camera.settled", attempt: effect.attempt, available: false }),
)
return
}
if (effect.type === "camera.timer.stop") {
clearTimeout(cameraTimer)
cameraTimer = undefined
return
}
if (effect.type === "connect.http") {
const failed = () =>
dispatch({
@@ -154,6 +175,7 @@ export function createServerConnectController(options: ServerConnectControllerOp
}
onCleanup(() => dispatch({ type: "disposed" }))
initial.effects.forEach(run)
const view = createMemo(() =>
selectServerConnectView(machine(), {
@@ -165,3 +187,26 @@ export function createServerConnectController(options: ServerConnectControllerOp
return { view, dispatch, redeem }
}
function cameraSupport(platform: string): ServerCameraSupport {
if (platform !== "web") return "none"
if (!window.isSecureContext) return "insecure"
if (!navigator.mediaDevices?.getUserMedia || !navigator.mediaDevices.enumerateDevices) return "unavailable"
return "probe"
}
async function probeCamera() {
const denied = await navigator.permissions?.query({ name: "camera" }).then(
(permission) => permission.state === "denied",
() => false,
)
if (denied) return false
const devices = await navigator.mediaDevices.enumerateDevices()
return devices.some((device) => device.kind === "videoinput")
}
+11 -22
View File
@@ -10,8 +10,6 @@ import { useLanguage } from "@/runtime/i18n/language"
import { ServerConnection, useServers } from "@/runtime/server/registry"
import { useTabs } from "@/shell/tabs/tabs"
import { isServerUnauthorized } from "@/runtime/server/health-machine"
import { usePlatform } from "@/runtime/platform/platform"
import { cameraHint, createCameraAvailability } from "./camera"
import { createServerConnectController } from "./controller"
import type { ServerConnectField, ServerOriginal } from "./machine"
import { ConnectMethodSwitch } from "./method"
@@ -26,11 +24,9 @@ export const DialogServer: Component<{
}> = (props) => {
const dialog = useDialog()
const language = useLanguage()
const platform = usePlatform()
const servers = useServers()
const global = useGlobal()
const tabs = useTabs()
const camera = createCameraAvailability()
const edited = props.mode === "edit" ? props.server : undefined
const originalOf = (server: ServerConnection.Http): ServerOriginal => ({
@@ -103,10 +99,7 @@ export const DialogServer: Component<{
fallback={
<Suspense fallback={<p role="status">{language.t("server.connect.camera.starting")}</p>}>
<PairingScanner
onCancel={() => {
form.dispatch({ type: "scan.cancelled" })
void camera.refetch()
}}
onCancel={() => form.dispatch({ type: "scan.cancelled" })}
redeem={form.redeem}
onScan={(link) => form.dispatch({ type: "scan.completed", link })}
/>
@@ -207,22 +200,18 @@ export const DialogServer: Component<{
</span>
</div>
</Show>
<Show when={view().draft.method === "link" && platform.platform === "web"}>
<Show
when={camera.available.latest || camera.available.loading}
fallback={<span class="settings-server-dialog-hint">{language.t(cameraHint())}</span>}
<Show when={view().showScan}>
<Button
variant="neutral"
size="large"
class="!w-full self-stretch"
disabled={!view().canScan}
onClick={() => form.dispatch({ type: "scan.started" })}
>
<Button
variant="neutral"
size="large"
class="!w-full self-stretch"
disabled={view().disabled || !camera.available.latest}
onClick={() => form.dispatch({ type: "scan.started" })}
>
{language.t("server.connect.scan")}
</Button>
</Show>
{language.t("server.connect.scan")}
</Button>
</Show>
<Show when={view().cameraHint}>{(hint) => <span class="settings-server-dialog-hint">{hint()}</span>}</Show>
<ConnectMethodSwitch
method={view().draft.method}
disabled={view().disabled}
@@ -1,9 +1,10 @@
import { describe, expect, test } from "bun:test"
import {
createServerConnectState,
CAMERA_PROBE_TIMEOUT_MS,
formatServerConnectError,
selectServerConnectView,
SERVER_CONNECT_TIMEOUT_MS,
startServerConnect,
transitionServerConnect,
type ServerConnectEffect,
type ServerConnectErrorContext,
@@ -23,17 +24,29 @@ const original = (input: Partial<ServerOriginal> = {}): ServerOriginal => ({
const edit = (input: Partial<ServerOriginal> = {}): ServerConnectTarget => ({ kind: "edit", original: original(input) })
function replay(target: ServerConnectTarget, events: readonly ServerConnectEvent[]) {
function replay(
target: ServerConnectTarget,
events: readonly ServerConnectEvent[],
from: ServerConnectState = startServerConnect(target).state,
) {
return events.reduce<{ state: ServerConnectState; effects: ServerConnectEffect[] }>(
(result, event) => {
const next = transitionServerConnect(result.state, event)
return { state: next.state, effects: [...result.effects, ...next.effects] }
},
{ state: createServerConnectState(target), effects: [] },
{ state: from, effects: [] },
)
}
/** The web app's form once its camera check found a camera. */
const withCamera = (target: ServerConnectTarget) =>
transitionServerConnect(startServerConnect(target, "probe").state, {
type: "camera.settled",
attempt: 1,
available: true,
}).state
const field = (name: "link" | "url" | "name" | "password", value: string): ServerConnectEvent => ({
type: "field.changed",
field: name,
@@ -131,10 +144,11 @@ describe("server connect form", () => {
})
test("a scanned link submits once", () => {
const scanned = replay({ kind: "add" }, [
{ type: "scan.started" },
{ type: "scan.completed", link: "http://192.168.1.2:4096/auth/connect/abc" },
])
const scanned = replay(
{ kind: "add" },
[{ type: "scan.started" }, { type: "scan.completed", link: "http://192.168.1.2:4096/auth/connect/abc" }],
withCamera({ kind: "add" }),
)
expect(scanned.state).toMatchObject({ status: "submitting", attempt: 1 })
expect(scanned.effects).toEqual([
@@ -155,15 +169,82 @@ describe("server connect form", () => {
).toBe(scanned.state)
})
test("a cancelled scan returns to the form with its values", () => {
const result = replay({ kind: "add" }, [
field("name", "Remote"),
{ type: "scan.started" },
{ type: "scan.cancelled" },
])
test("a cancelled scan returns to the form with its values and checks the camera again", () => {
const result = replay(
{ kind: "add" },
[field("name", "Remote"), { type: "scan.started" }, { type: "scan.cancelled" }],
withCamera({ kind: "add" }),
)
expect(result.state).toMatchObject({ status: "editing", draft: { name: "Remote" } })
expect(result.effects).toEqual([])
expect(result.effects).toEqual([{ type: "camera.probe", attempt: 2, timeoutMs: CAMERA_PROBE_TIMEOUT_MS }])
})
test("a camera check that never answers gives way to the hint", () => {
const start = startServerConnect({ kind: "add" }, "probe")
expect(start.effects).toEqual([{ type: "camera.probe", attempt: 1, timeoutMs: CAMERA_PROBE_TIMEOUT_MS }])
expect(selectServerConnectView(start.state, context)).toMatchObject({
showScan: true,
canScan: false,
cameraHint: undefined,
})
const timedOut = transitionServerConnect(start.state, { type: "camera.timed-out", attempt: 1 })
expect(timedOut.effects).toEqual([{ type: "camera.timer.stop" }])
expect(selectServerConnectView(timedOut.state, context)).toMatchObject({
showScan: false,
canScan: false,
cameraHint: "server.connect.camera.unavailable",
})
})
test("after a cancelled scan, Scan waits for the new camera check and follows its answer", () => {
const cancelled = replay(
{ kind: "add" },
[{ type: "scan.started" }, { type: "scan.cancelled" }],
withCamera({ kind: "add" }),
)
expect(selectServerConnectView(cancelled.state, context).canScan).toBe(false)
expect(transitionServerConnect(cancelled.state, { type: "scan.started" }).state).toBe(cancelled.state)
// The answer of the first check is stale.
expect(
transitionServerConnect(cancelled.state, { type: "camera.settled", attempt: 1, available: true }).state,
).toBe(cancelled.state)
const denied = transitionServerConnect(cancelled.state, { type: "camera.settled", attempt: 2, available: false })
expect(selectServerConnectView(denied.state, context)).toMatchObject({
canScan: false,
cameraHint: "server.connect.camera.unavailable",
})
})
test.each([
{ support: "insecure", showScan: false, cameraHint: "server.connect.camera.native" },
{ support: "unavailable", showScan: false, cameraHint: "server.connect.camera.unavailable" },
{ support: "none", showScan: false, cameraHint: undefined },
] as const)("a $support camera shows its hint at once, with no check", (input) => {
const start = startServerConnect({ kind: "add" }, input.support)
expect(start.effects).toEqual([])
expect(selectServerConnectView(start.state, context)).toMatchObject({
showScan: input.showScan,
cameraHint: input.cameraHint,
})
expect(transitionServerConnect(start.state, { type: "scan.started" }).state).toBe(start.state)
})
test("closing during a camera check stops its timer and ignores its answer", () => {
const closed = transitionServerConnect(startServerConnect({ kind: "add" }, "probe").state, { type: "disposed" })
expect(closed.effects).toEqual([{ type: "camera.timer.stop" }])
expect(transitionServerConnect(closed.state, { type: "camera.settled", attempt: 1, available: true }).state).toBe(
closed.state,
)
})
test("a result after the dialog unmounts saves nothing", () => {
@@ -341,7 +422,7 @@ describe("server connect form", () => {
})
test("an edit starts from the server, on a pairing link when it signed out", () => {
const view = (target: ServerConnectTarget) => selectServerConnectView(createServerConnectState(target), context)
const view = (target: ServerConnectTarget) => selectServerConnectView(startServerConnect(target).state, context)
expect(view(edit({ displayName: "Remote", password: "secret" })).draft).toEqual({
method: "password",
+112 -22
View File
@@ -9,6 +9,21 @@ import { bareServerAddress, legacyPairingLink, pairingLink, serverAddress } from
*/
export const SERVER_CONNECT_TIMEOUT_MS = 75_000
/** A wedged camera daemon can leave `enumerateDevices` pending; past this the scan button gives way to the hint. */
export const CAMERA_PROBE_TIMEOUT_MS = 3_000
/** What the page can tell about the camera before probing: nothing to show off the web, or a probe to run. */
export type ServerCameraSupport = "none" | "insecure" | "unavailable" | "probe"
export type ServerCameraState =
/** Not the web app: the native apps pair by pasted link. */
| { readonly status: "hidden" }
/** A plain-HTTP page cannot open the camera. */
| { readonly status: "insecure" }
| { readonly status: "probing"; readonly attempt: number }
| { readonly status: "available" }
| { readonly status: "unavailable" }
/** The saved server an edit form started from, as it is now. */
export type ServerOriginal = {
readonly url: string
@@ -48,6 +63,8 @@ export type ServerSaveAction =
type Form = {
readonly attempt: number
readonly cameraAttempt: number
readonly camera: ServerCameraState
readonly target: ServerConnectTarget
readonly draft: ServerConnectDraft
}
@@ -69,6 +86,8 @@ export type ServerConnectState =
export type ServerConnectEvent =
| { readonly type: "method.changed"; readonly method: ConnectMethod }
| { readonly type: "field.changed"; readonly field: ServerConnectField; readonly value: string }
| { readonly type: "camera.settled"; readonly attempt: number; readonly available: boolean }
| { readonly type: "camera.timed-out"; readonly attempt: number }
| { readonly type: "scan.started" }
| { readonly type: "scan.cancelled" }
| { readonly type: "scan.completed"; readonly link: string }
@@ -92,6 +111,9 @@ export type ServerConnectEffect =
| { readonly type: "connect.http"; readonly attempt: number; readonly http: ServerConnection.HttpBase }
| { readonly type: "timer.start"; readonly attempt: number; readonly timeoutMs: number }
| { readonly type: "timer.stop" }
/** Check for a camera, and dispatch `camera.timed-out` after `timeoutMs`. */
| { readonly type: "camera.probe"; readonly attempt: number; readonly timeoutMs: number }
| { readonly type: "camera.timer.stop" }
| { readonly type: "save"; readonly action: ServerSaveAction }
| { readonly type: "close"; readonly saved?: ServerConnection.Http }
@@ -100,8 +122,19 @@ export type ServerConnectTransition = {
readonly effects: readonly ServerConnectEffect[]
}
export function createServerConnectState(target: ServerConnectTarget): ServerConnectState {
return { status: "editing", attempt: 0, target, draft: initialDraft(target) }
export function startServerConnect(
target: ServerConnectTarget,
support: ServerCameraSupport = "none",
): ServerConnectTransition {
const base = { status: "editing", attempt: 0, cameraAttempt: 0, target, draft: initialDraft(target) } as const
if (support === "probe")
return {
state: { ...base, cameraAttempt: 1, camera: { status: "probing", attempt: 1 } },
effects: [probe(1)],
}
return { state: { ...base, camera: { status: support === "none" ? "hidden" : support } }, effects: [] }
}
export function transitionServerConnect(state: ServerConnectState, event: ServerConnectEvent): ServerConnectTransition {
@@ -109,13 +142,35 @@ export function transitionServerConnect(state: ServerConnectState, event: Server
if (state.status === "closed") return same
if (event.type === "disposed")
return { state: { ...form(state), status: "closed" }, effects: state.status === "submitting" ? [stop] : [] }
if (event.type === "disposed") return close(state, state.status === "submitting" ? [stop] : [])
if (event.type === "original.synced") return synced(state, event.original)
if (event.type === "camera.settled" || event.type === "camera.timed-out") {
if (state.camera.status !== "probing" || state.camera.attempt !== event.attempt) return same
const available = event.type === "camera.settled" && event.available
return {
state: { ...state, camera: { status: available ? "available" : "unavailable" } },
effects: [{ type: "camera.timer.stop" }],
}
}
if (state.status === "scanning") {
if (event.type === "scan.cancelled") return { state: { ...form(state), status: "editing" }, effects: [] }
// The scanner may have just been denied the camera, so it is checked again before Scan is offered.
if (event.type === "scan.cancelled") {
const cameraAttempt = state.cameraAttempt + 1
return {
state: {
...form(state),
status: "editing",
cameraAttempt,
camera: { status: "probing", attempt: cameraAttempt },
},
effects: [probe(cameraAttempt)],
}
}
if (event.type === "scan.completed") return submit(state, { ...state.draft, method: "link", link: event.link })
@@ -149,7 +204,11 @@ export function transitionServerConnect(state: ServerConnectState, event: Server
return { state: editing(state, { ...state.draft, [event.field]: event.value }), effects: [] }
}
if (event.type === "scan.started") return { state: { ...form(state), status: "scanning" }, effects: [] }
if (event.type === "scan.started") {
if (state.camera.status !== "available") return same
return { state: { ...form(state), status: "scanning" }, effects: [] }
}
if (event.type === "submitted") return submit(state, state.draft)
@@ -165,11 +224,16 @@ export type ServerConnectErrorKey =
| "server.connect.failed"
| "dialog.server.add.error"
export type ServerConnectViewKey =
| ServerConnectErrorKey
| "server.connect.camera.unavailable"
| "server.connect.camera.native"
export type ServerConnectErrorContext = {
readonly surface: "screen" | "dialog"
/** Set on the web app, where an HTTPS page cannot reach a plain-HTTP address. */
readonly pageHref: string | undefined
readonly t: (key: ServerConnectErrorKey) => string
readonly t: (key: ServerConnectViewKey) => string
}
export function formatServerConnectError(error: ServerConnectError, context: ServerConnectErrorContext) {
@@ -187,9 +251,15 @@ export function formatServerConnectError(error: ServerConnectError, context: Ser
}
export function selectServerConnectView(state: ServerConnectState, context: ServerConnectErrorContext) {
const primary = state.draft.method === "link" ? state.draft.link : state.draft.url
const link = state.draft.method === "link"
const primary = link ? state.draft.link : state.draft.url
const camera = state.camera.status
return {
// Shown, disabled, while the camera check runs, so the hint does not flash in first.
showScan: link && (camera === "available" || camera === "probing"),
canScan: state.status === "editing" && link && camera === "available",
cameraHint: link ? cameraHint(camera, context) : undefined,
scanning: state.status === "scanning",
busy: state.status === "submitting",
disabled: state.status !== "editing",
@@ -202,8 +272,29 @@ export function selectServerConnectView(state: ServerConnectState, context: Serv
export type ServerConnectView = ReturnType<typeof selectServerConnectView>
// QR codes carry JSON, not a link, so on a plain-HTTP page the pasted link is the way in.
function cameraHint(camera: ServerCameraState["status"], context: ServerConnectErrorContext) {
if (camera === "insecure") return context.t("server.connect.camera.native")
if (camera === "unavailable") return context.t("server.connect.camera.unavailable")
return undefined
}
const stop = { type: "timer.stop" } as const
function probe(attempt: number): ServerConnectEffect {
return { type: "camera.probe", attempt, timeoutMs: CAMERA_PROBE_TIMEOUT_MS }
}
/** Closes the form, stopping a camera check that is still running. */
function close(state: Form, effects: readonly ServerConnectEffect[]): ServerConnectTransition {
return {
state: { ...form(state), status: "closed" },
effects: state.camera.status === "probing" ? [...effects, { type: "camera.timer.stop" }] : effects,
}
}
function initialDraft(target: ServerConnectTarget): ServerConnectDraft {
if (target.kind !== "edit")
return {
@@ -225,11 +316,17 @@ function initialDraft(target: ServerConnectTarget): ServerConnectDraft {
}
function form(state: Form): Form {
return { attempt: state.attempt, target: state.target, draft: state.draft }
return {
attempt: state.attempt,
cameraAttempt: state.cameraAttempt,
camera: state.camera,
target: state.target,
draft: state.draft,
}
}
function editing(state: Form, draft: ServerConnectDraft, error?: ServerConnectError): ServerConnectState {
return { status: "editing", attempt: state.attempt, target: state.target, draft, error }
return { ...form(state), status: "editing", draft, error }
}
// Where the form points: a pasted or scanned pairing link wins, in either field; else the address and password.
@@ -245,7 +342,7 @@ function submit(state: Form, draft: ServerConnectDraft): ServerConnectTransition
const fallbackUrl = preferredUrl ?? link.urls[0] ?? value
return {
state: { status: "submitting", attempt, target: state.target, draft, fallbackUrl },
state: { ...form(state), status: "submitting", attempt, draft, fallbackUrl },
effects: [{ type: "connect.link", attempt, link: value, preferredUrl, fallbackUrl }, timer],
}
}
@@ -275,12 +372,12 @@ function submit(state: Form, draft: ServerConnectDraft): ServerConnectTransition
(draft.name.trim() || undefined) === original.displayName &&
password === original.password
)
return { state: { ...form(state), draft, status: "closed" }, effects: [{ type: "close" }] }
return close({ ...state, draft }, [{ type: "close" }])
const http = password ? { url, password } : { url }
return {
state: { status: "submitting", attempt, target: state.target, draft, fallbackUrl: url },
state: { ...form(state), status: "submitting", attempt, draft, fallbackUrl: url },
effects: [{ type: "connect.http", attempt, http }, timer],
}
}
@@ -300,10 +397,7 @@ function saved(state: Form, http: ServerConnection.HttpBase): ServerConnectTrans
? { type: "replace", originalUrl: original.url, connection }
: { type: "add", connection }
return {
state: { ...form(state), status: "closed" },
effects: [stop, { type: "save", action }, { type: "close", saved: connection }],
}
return close(state, [stop, { type: "save", action }, { type: "close", saved: connection }])
}
function synced(
@@ -313,11 +407,7 @@ function synced(
if (state.target.kind !== "edit") return { state, effects: [] }
// The edited server was removed elsewhere: there is nothing left to save to.
if (!original)
return {
state: { ...form(state), status: "closed" },
effects: [...(state.status === "submitting" ? [stop] : []), { type: "close" }],
}
if (!original) return close(state, [...(state.status === "submitting" ? [stop] : []), { type: "close" }])
const current = state.target.original
+10 -21
View File
@@ -3,8 +3,6 @@ import { Button } from "@opencode/ui/button"
import { TextInput } from "@opencode/ui/text-input"
import { Wordmark } from "@opencode/ui/wordmark"
import { useLanguage } from "@/runtime/i18n/language"
import { usePlatform } from "@/runtime/platform/platform"
import { cameraHint, createCameraAvailability } from "./camera"
import { createServerConnectController } from "./controller"
import { ConnectMethodSwitch } from "./method"
import "./screen.css"
@@ -13,8 +11,6 @@ const PairingScanner = lazy(() => import("./scanner").then((module) => ({ defaul
export function ConnectServerScreen(props: { url?: string } = {}) {
const language = useLanguage()
const platform = usePlatform()
const camera = createCameraAvailability()
// Read once: the screen leaves when the server it signs in to answers, so its address does not change while it shows.
const form = createServerConnectController({ surface: "screen", target: { kind: "connect", url: props.url } })
const view = form.view
@@ -39,10 +35,7 @@ export function ConnectServerScreen(props: { url?: string } = {}) {
<Suspense fallback={<p role="status">{language.t("server.connect.camera.starting")}</p>}>
<PairingScanner
redeem={form.redeem}
onCancel={() => {
form.dispatch({ type: "scan.cancelled" })
void camera.refetch()
}}
onCancel={() => form.dispatch({ type: "scan.cancelled" })}
onScan={(link) => form.dispatch({ type: "scan.completed", link })}
/>
</Suspense>
@@ -131,21 +124,17 @@ export function ConnectServerScreen(props: { url?: string } = {}) {
{language.t(view().busy ? "dialog.server.add.checking" : "server.connect.button")}
</Button>
</form>
<Show when={view().draft.method === "link" && platform.platform === "web"}>
<Show
when={camera.available.latest || camera.available.loading}
fallback={<p>{language.t(cameraHint())}</p>}
<Show when={view().showScan}>
<Button
variant="neutral"
size="large"
disabled={!view().canScan}
onClick={() => form.dispatch({ type: "scan.started" })}
>
<Button
variant="neutral"
size="large"
disabled={view().disabled || !camera.available.latest}
onClick={() => form.dispatch({ type: "scan.started" })}
>
{language.t("server.connect.scan")}
</Button>
</Show>
{language.t("server.connect.scan")}
</Button>
</Show>
<Show when={view().cameraHint}>{(hint) => <p>{hint()}</p>}</Show>
<ConnectMethodSwitch
method={view().draft.method}
disabled={view().disabled}
+47 -25
View File
@@ -1,4 +1,10 @@
import { onCleanup } from "solid-js"
import {
createSoundPreviewState,
transitionSoundPreview,
type SoundPreviewEffect,
type SoundPreviewEvent,
} from "./sound-preview-machine"
type ShellOption = {
path: string
@@ -43,38 +49,54 @@ export function createShellOptions(input: { shells: ShellOption[]; current: stri
}
export function createSoundPreviewController(player: (id: string | undefined) => Promise<(() => void) | undefined>) {
let cleanup: (() => void) | undefined
let timeout: ReturnType<typeof setTimeout> | undefined
let run = 0
let state = createSoundPreviewState()
let timer: ReturnType<typeof setTimeout> | undefined
const stop = () => {
run += 1
cleanup?.()
clearTimeout(timeout)
cleanup = undefined
timeout = undefined
const dispatch = (event: SoundPreviewEvent) => {
const next = transitionSoundPreview(state, event)
state = next.state
next.effects.forEach(run)
}
const play = (id: string | undefined) => {
stop()
const run = (effect: SoundPreviewEffect) => {
if (effect.type === "timer.start") {
clearTimeout(timer)
timer = setTimeout(
() =>
dispatch(
effect.kind === "debounce"
? { type: "debounce.elapsed", attempt: effect.attempt }
: { type: "load.timed-out", attempt: effect.attempt },
),
effect.delayMs,
)
if (!id) return
const current = ++run
timeout = setTimeout(() => {
timeout = undefined
void player(id).then((next) => {
if (run === current) {
cleanup = next
return
}
return
}
if (effect.type === "timer.stop") {
clearTimeout(timer)
timer = undefined
next?.()
})
}, 100)
return
}
if (effect.type === "audio.load") {
void Promise.try(() => player(effect.id)).then(
(active) => dispatch({ type: "load.succeeded", attempt: effect.attempt, active }),
() => dispatch({ type: "load.failed", attempt: effect.attempt }),
)
return
}
effect.active()
}
onCleanup(stop)
onCleanup(() => dispatch({ type: "disposed" }))
return { play, stop }
return {
play: (id: string | undefined) => dispatch({ type: "play.requested", id }),
stop: () => dispatch({ type: "stop.requested" }),
}
}
@@ -0,0 +1,114 @@
import { describe, expect, test } from "bun:test"
import {
createSoundPreviewState,
SOUND_PREVIEW_DEBOUNCE_MS,
SOUND_PREVIEW_LOAD_TIMEOUT_MS,
transitionSoundPreview,
type SoundPreviewEffect,
type SoundPreviewEvent,
type SoundPreviewState,
} from "./sound-preview-machine"
type Stop = string
function replay(events: readonly SoundPreviewEvent<Stop>[], from = createSoundPreviewState<Stop>()) {
return events.reduce<{ state: SoundPreviewState<Stop>; effects: SoundPreviewEffect<Stop>[] }>(
(result, event) => {
const next = transitionSoundPreview(result.state, event)
return { state: next.state, effects: [...result.effects, ...next.effects] }
},
{ state: from, effects: [] },
)
}
const loading = (id: string): SoundPreviewEvent<Stop>[] => [
{ type: "play.requested", id },
{ type: "debounce.elapsed", attempt: 1 },
]
describe("sound preview machine", () => {
test.each([
{ name: "while waiting", events: [{ type: "play.requested", id: "alert-01" }], released: { type: "timer.stop" } },
{
name: "while playing",
events: [...loading("alert-01"), { type: "load.succeeded", attempt: 1, active: "stop-a" }],
released: { type: "audio.stop", active: "stop-a" },
},
] as const)("a preview asked for after unmount $name does nothing", (input) => {
const disposed = replay([...input.events, { type: "disposed" }])
expect(disposed.state).toEqual({ status: "disposed" })
expect(disposed.effects.at(-1)).toEqual(input.released)
expect(transitionSoundPreview(disposed.state, { type: "play.requested", id: "alert-01" })).toEqual({
state: disposed.state,
effects: [],
})
})
test("a sound that loads after unmount is stopped as it arrives", () => {
const disposed = replay([...loading("alert-01"), { type: "disposed" }])
expect(transitionSoundPreview(disposed.state, { type: "load.succeeded", attempt: 1, active: "stop-a" })).toEqual({
state: disposed.state,
effects: [{ type: "audio.stop", active: "stop-a" }],
})
})
test.each([{ type: "load.failed", attempt: 1 } as const, { type: "load.timed-out", attempt: 1 } as const])(
"$type settles back to idle",
(event) => {
const result = replay([...loading("alert-01"), event])
expect(result.effects).toEqual([
{ type: "timer.start", kind: "debounce", attempt: 1, delayMs: SOUND_PREVIEW_DEBOUNCE_MS },
{ type: "audio.load", attempt: 1, id: "alert-01" },
{ type: "timer.start", kind: "load", attempt: 1, delayMs: SOUND_PREVIEW_LOAD_TIMEOUT_MS },
{ type: "timer.stop" },
])
expect(result.state).toEqual({ status: "idle", attempt: 1 })
// A load that timed out and answers late plays nothing.
expect(transitionSoundPreview(result.state, { type: "load.succeeded", attempt: 1, active: "stop-a" })).toEqual({
state: result.state,
effects: [{ type: "audio.stop", active: "stop-a" }],
})
},
)
test("a new preview stops the one playing and waits again", () => {
const playing = replay([...loading("alert-01"), { type: "load.succeeded", attempt: 1, active: "stop-a" }])
expect(transitionSoundPreview(playing.state, { type: "play.requested", id: "alert-02" }).effects).toEqual([
{ type: "audio.stop", active: "stop-a" },
{ type: "timer.start", kind: "debounce", attempt: 2, delayMs: SOUND_PREVIEW_DEBOUNCE_MS },
])
})
test("a load superseded by another preview is stopped without touching the new one", () => {
const superseded = replay([...loading("alert-01"), { type: "play.requested", id: "alert-02" }])
const late = transitionSoundPreview(superseded.state, { type: "load.succeeded", attempt: 1, active: "stop-a" })
expect(late).toEqual({ state: superseded.state, effects: [{ type: "audio.stop", active: "stop-a" }] })
expect(late.state).toEqual({ status: "debouncing", attempt: 2, id: "alert-02" })
})
test("only the last of several quick previews loads", () => {
const result = replay([
{ type: "play.requested", id: "alert-01" },
{ type: "play.requested", id: "alert-02" },
{ type: "debounce.elapsed", attempt: 1 },
{ type: "debounce.elapsed", attempt: 2 },
])
expect(result.effects.filter((effect) => effect.type === "audio.load")).toEqual([
{ type: "audio.load", attempt: 2, id: "alert-02" },
])
})
test("stopping an idle preview changes nothing", () => {
const state = createSoundPreviewState<Stop>()
expect(transitionSoundPreview(state, { type: "stop.requested" })).toEqual({ state, effects: [] })
})
})
@@ -0,0 +1,109 @@
/** Moving through the sound list plays only the sound it settles on. */
export const SOUND_PREVIEW_DEBOUNCE_MS = 100
/** A sound file that never loads gives up rather than playing long after the user moved on. */
export const SOUND_PREVIEW_LOAD_TIMEOUT_MS = 5_000
export type SoundPreviewState<Stop = () => void> =
| { readonly status: "idle"; readonly attempt: number }
| { readonly status: "debouncing"; readonly attempt: number; readonly id: string }
| { readonly status: "loading"; readonly attempt: number; readonly id: string }
| { readonly status: "playing"; readonly attempt: number; readonly id: string; readonly active: Stop }
| { readonly status: "disposed" }
export type SoundPreviewEvent<Stop = () => void> =
| { readonly type: "play.requested"; readonly id: string | undefined }
| { readonly type: "stop.requested" }
| { readonly type: "debounce.elapsed"; readonly attempt: number }
/** `active` stops the sound; none when nothing played. */
| { readonly type: "load.succeeded"; readonly attempt: number; readonly active: Stop | undefined }
| { readonly type: "load.failed"; readonly attempt: number }
| { readonly type: "load.timed-out"; readonly attempt: number }
| { readonly type: "disposed" }
export type SoundPreviewEffect<Stop = () => void> =
/** Replaces any running timer; dispatches `debounce.elapsed` or `load.timed-out` with `attempt`. */
| {
readonly type: "timer.start"
readonly kind: "debounce" | "load"
readonly attempt: number
readonly delayMs: number
}
| { readonly type: "timer.stop" }
| { readonly type: "audio.load"; readonly attempt: number; readonly id: string }
| { readonly type: "audio.stop"; readonly active: Stop }
export type SoundPreviewTransition<Stop = () => void> = {
readonly state: SoundPreviewState<Stop>
readonly effects: readonly SoundPreviewEffect<Stop>[]
}
export function createSoundPreviewState<Stop = () => void>(): SoundPreviewState<Stop> {
return { status: "idle", attempt: 0 }
}
export function transitionSoundPreview<Stop>(
state: SoundPreviewState<Stop>,
event: SoundPreviewEvent<Stop>,
): SoundPreviewTransition<Stop> {
// A sound that loads after it was superseded, stopped or unmounted is stopped as it arrives.
if (event.type === "load.succeeded" && (state.status !== "loading" || state.attempt !== event.attempt))
return { state, effects: event.active === undefined ? [] : [{ type: "audio.stop", active: event.active }] }
if (state.status === "disposed") return { state, effects: [] }
if (event.type === "disposed") return { state: { status: "disposed" }, effects: release(state) }
if (event.type === "play.requested" || event.type === "stop.requested") {
const id = event.type === "play.requested" ? event.id : undefined
if (!id) {
if (state.status === "idle") return { state, effects: [] }
return { state: { status: "idle", attempt: state.attempt + 1 }, effects: release(state) }
}
const attempt = state.attempt + 1
return {
state: { status: "debouncing", attempt, id },
effects: [
...(state.status === "playing" ? release(state) : []),
{ type: "timer.start", kind: "debounce", attempt, delayMs: SOUND_PREVIEW_DEBOUNCE_MS },
],
}
}
if (event.type === "debounce.elapsed") {
if (state.status !== "debouncing" || state.attempt !== event.attempt) return { state, effects: [] }
return {
state: { status: "loading", attempt: state.attempt, id: state.id },
effects: [
{ type: "audio.load", attempt: state.attempt, id: state.id },
{ type: "timer.start", kind: "load", attempt: state.attempt, delayMs: SOUND_PREVIEW_LOAD_TIMEOUT_MS },
],
}
}
if (state.status !== "loading" || state.attempt !== event.attempt) return { state, effects: [] }
if (event.type === "load.succeeded" && event.active !== undefined)
return {
state: { status: "playing", attempt: state.attempt, id: state.id, active: event.active },
effects: [STOP],
}
return { state: { status: "idle", attempt: state.attempt }, effects: [STOP] }
}
const STOP = { type: "timer.stop" } as const
/** What leaving `state` must stop: its timer or its sound. */
function release<Stop>(state: SoundPreviewState<Stop>): SoundPreviewEffect<Stop>[] {
if (state.status === "debouncing" || state.status === "loading") return [STOP]
if (state.status === "playing") return [{ type: "audio.stop", active: state.active }]
return []
}