mirror of
https://github.com/anomalyco/opencode.git
synced 2026-11-21 04:12:08 +03:00
fix(app): switch language atomically and bound camera, sound preview and lab browsing (#62121)
This commit is contained in:
committed by
GitHub
Unverified
parent
47cace689a
commit
b903ae5cc9
@@ -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: {
|
||||
|
||||
@@ -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 }
|
||||
}
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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: [],
|
||||
})
|
||||
})
|
||||
})
|
||||
@@ -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"
|
||||
}
|
||||
@@ -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")
|
||||
}
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
@@ -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}
|
||||
|
||||
@@ -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 []
|
||||
}
|
||||
Reference in New Issue
Block a user