diff --git a/packages/gui-plugins/src/microsoft-office/document.tsx b/packages/gui-plugins/src/microsoft-office/document.tsx index 7d237f7f785..7335930c7f6 100644 --- a/packages/gui-plugins/src/microsoft-office/document.tsx +++ b/packages/gui-plugins/src/microsoft-office/document.tsx @@ -1,7 +1,8 @@ -import { createSignal, For, onCleanup, Show, type Accessor } from "solid-js" +import { For, onCleanup, Show, type Accessor } from "solid-js" import { createStore } from "solid-js/store" import { Loader } from "@opencode/ui/loader" -import { createKeyed, createLatest, usePlugin } from "@opencode/plugin/gui" +import { createLatest, usePlugin } from "@opencode/plugin/gui" +import { createOfficeWorker, type WorkerClient } from "./office-worker" import { OfficePages, type PaintPage, type ScrollToPage } from "./pages" import { layerFont, @@ -11,7 +12,7 @@ import { type WordPageSize, type WordSpan, } from "./word-protocol" -import { createWorkerClient, movableBuffer } from "./worker-rpc" +import { WorkerClosedError } from "./worker-rpc" import type { FileViewerProps } from "@opencode/plugin/gui/file" type Opened = { @@ -27,7 +28,7 @@ type Opened = { readonly finish: () => Promise } -type Client = ReturnType> +type Client = WorkerClient /** Scrolls the page column; set once the column mounts. */ type Scroll = { to: ScrollToPage | undefined } @@ -44,105 +45,101 @@ type Lazy = { value: T | undefined } * each page makes its text selectable, findable and readable, and its links followable. */ export default function OfficeDocument(props: FileViewerProps) { - const ctx = usePlugin() - const [opened, setOpened] = createSignal() - - // Syncs one document worker with the loaded bytes. Terminating it is what frees the engine's memory. - createKeyed( - () => props.bytes, - (bytes) => { - const controller = new AbortController() - const worker = new Worker(new URL("./document.worker.ts", import.meta.url), { type: "module" }) - const client = createWorkerClient(worker) - - const fail = () => { - if (controller.signal.aborted) return - - controller.abort() - props.onError() - } - - // A worker that dies after the pages showed takes them with it. - worker.addEventListener("error", fail) - worker.addEventListener("messageerror", fail) - onCleanup(() => { - controller.abort() - client.close() - setOpened(undefined) - }) - - void open(client, bytes) - .then((value) => { - if (controller.signal.aborted) return - - setOpened(value) - - // The worker runs calls in order, so the full layout waits until the first pages have asked for their paints: - // they do once the column is laid out and its observer reports them, which takes up to two frames. - return new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve))) - .then(() => (controller.signal.aborted ? undefined : value.finish())) - .then((count) => { - if (count !== undefined && !controller.signal.aborted) props.onDetails([ctx.plural("pages", count)]) - }) - }) - .catch(fail) - }, - ) + // A worker that dies after the pages showed takes them with it. + const viewer = createOfficeWorker({ + bytes: () => props.bytes, + createWorker: () => new Worker(new URL("./document.worker.ts", import.meta.url), { type: "module" }), + open: async (client, buffer, signal) => ({ value: await open(client, buffer, signal) }), + onDetails: (details) => props.onDetails(details), + onError: () => props.onError(), + }) return ( - - + +
+ +
+
} > - {(opened) => { - const scroll: Scroll = { to: undefined } - - const follow = (link: WordLink) => { - if (link.kind === "external") return ctx.system.openExternal(link.url) - - void opened() - .bookmark(link.bookmark) - .then( - (target) => { - if (target) scroll.to?.(target.index, target.y) - }, - () => undefined, - ) - } - - return ( - ctx.t("page", { number: index + 1 })} - overlay={(input) => ( - - )} - text - footer={(index) => ( - - - - )} - onScrollTo={(scrollTo) => { - scroll.to = scrollTo - }} - /> - ) - }} + {(opened) => ( + props.onDetails(details)} + onError={() => props.onError()} + /> + )}
) } +/** One opened document's pages. A reloaded file mounts a new one. */ +function DocumentContent(props: { + opened: Opened + onDetails: (details: readonly string[]) => void + onError: () => void +}) { + const ctx = usePlugin() + const scroll: Scroll = { to: undefined } + const controller = new AbortController() + + onCleanup(() => controller.abort()) + + // The worker runs calls in order, so the full layout waits until the first pages have asked for their paints: they + // do once the column is laid out and its observer reports them, which takes up to two frames. + void new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve))) + .then(() => (controller.signal.aborted ? undefined : props.opened.finish())) + .then( + (count) => { + if (count !== undefined && !controller.signal.aborted) props.onDetails([ctx.plural("pages", count)]) + }, + (error: Error) => { + // A worker that stopped reports itself through the viewer's worker. + if (!controller.signal.aborted && !(error instanceof WorkerClosedError)) props.onError() + }, + ) + + const follow = (link: WordLink) => { + if (link.kind === "external") return ctx.system.openExternal(link.url) + + void props.opened.bookmark(link.bookmark).then( + (target) => { + if (target) scroll.to?.(target.index, target.y) + }, + () => undefined, + ) + } + + return ( + ctx.t("page", { number: index + 1 })} + overlay={(input) => ( + + )} + text + footer={(index) => ( + + + + )} + onScrollTo={(scrollTo) => { + scroll.to = scrollTo + }} + /> + ) +} + /** * Transparent text over a page's painted glyphs. Positions are fractions of the page and sizes fractions of its width * (container query units), so the layer tracks the page's CSS size at once while a resize waits to repaint. @@ -221,10 +218,8 @@ function place(span: WordSpan) { } /** Opens the bytes in the worker and returns as soon as the document's first pages can show. */ -async function open(client: Client, bytes: Uint8Array): Promise { - // The view owns its bytes, so they move to the worker rather than being copied. - const buffer = movableBuffer(bytes) - const first = await client.call("open", { bytes: buffer }, { transfer: [buffer] }) +async function open(client: Client, buffer: ArrayBuffer, signal: AbortSignal): Promise { + const first = await client.call("open", { bytes: buffer }, { transfer: [buffer], signal }) const [layout, setLayout] = createStore({ pages: first.pages, loading: first.loading }) const layOut = async (): Promise => { diff --git a/packages/gui-plugins/src/microsoft-office/office-worker.ts b/packages/gui-plugins/src/microsoft-office/office-worker.ts new file mode 100644 index 00000000000..c867be2ecad --- /dev/null +++ b/packages/gui-plugins/src/microsoft-office/office-worker.ts @@ -0,0 +1,125 @@ +import { createMemo, createSignal, onCleanup, untrack } from "solid-js" +import { createKeyed } from "@opencode/plugin/gui" +import { + transitionWorker, + workerLoading, + workerOpened, + type WorkerEffect, + type WorkerEvent, + type WorkerState, +} from "./worker-machine" +import { createWorkerClient, movableBuffer, type Methods } from "./worker-rpc" + +/** The window's end of a viewer's worker. */ +export type WorkerClient = ReturnType> + +/** What a viewer's open returns: what it shows the file with, and the facts the toolbar shows when it knows them. */ +export type OfficeOpened = { readonly value: T; readonly details?: readonly string[] } + +/** One attempt's worker, until it closes. */ +type Run = { + readonly controller: AbortController + readonly close: () => void + readonly timer: ReturnType +} + +/** + * Syncs one worker with the view's bytes: each new array opens in a worker of its own, and the previous one is + * terminated, which frees its engine's memory. Open failures, timeouts and crashes report `onError` once per attempt. + */ +export function createOfficeWorker(options: { + readonly bytes: () => Uint8Array + /** Builds the worker; each caller keeps its own `new Worker(new URL(...))` so the bundler finds the script. */ + readonly createWorker: () => Worker + /** Opens the bytes, which move to the worker; resolves undefined when the file cannot be opened. */ + readonly open: ( + client: WorkerClient, + buffer: ArrayBuffer, + signal: AbortSignal, + ) => Promise | undefined> + readonly onDetails: (details: readonly string[]) => void + readonly onError: () => void +}) { + const [workerState, setWorkerState] = createSignal>({ status: "idle" }) + const runs = new Map() + // Effects can dispatch while they run (reporting an error may unmount the view), so events apply one at a time. + const queue: WorkerEvent[] = [] + + const dispatch = (event: WorkerEvent) => { + queue.push(event) + + if (queue.length === 1) drain() + } + + const drain = () => { + const event = queue[0] + + if (!event) return + + const next = transitionWorker(untrack(workerState), event) + + setWorkerState(() => next.state) + next.effects.forEach(run) + queue.shift() + drain() + } + + const run = (effect: WorkerEffect) => { + if (effect.type === "open-worker") return start(effect.attempt, effect.bytes, effect.timeoutMs) + + if (effect.type === "cancel-open-timeout") return clearTimeout(runs.get(effect.attempt)?.timer) + + if (effect.type === "close-worker") return close(effect.attempt) + + if (effect.type === "report-details") return options.onDetails(effect.details) + + options.onError() + } + + const start = (attempt: number, bytes: Uint8Array, timeoutMs: number) => { + const controller = new AbortController() + const worker = options.createWorker() + const client = createWorkerClient(worker) + const crashed = () => dispatch({ type: "worker.crashed", attempt }) + + worker.addEventListener("error", crashed) + worker.addEventListener("messageerror", crashed) + runs.set(attempt, { + controller, + close: () => client.close(), + timer: setTimeout(() => dispatch({ type: "open.timed-out", attempt }), timeoutMs), + }) + + // The view owns its bytes, so they move to the worker rather than being copied. + void options.open(client, movableBuffer(bytes), controller.signal).then( + (opened) => + dispatch( + opened + ? { type: "open.succeeded", attempt, value: opened.value, details: opened.details } + : { type: "open.failed", attempt }, + ), + () => dispatch({ type: "open.failed", attempt }), + ) + } + + const close = (attempt: number) => { + const entry = runs.get(attempt) + + if (!entry) return + + runs.delete(attempt) + clearTimeout(entry.timer) + entry.controller.abort() + entry.close() + } + + createKeyed(options.bytes, (bytes) => dispatch({ type: "bytes.changed", bytes })) + onCleanup(() => dispatch({ type: "disposed" })) + + return { + /** Whether the viewer shows its loader. */ + loading: createMemo(() => workerLoading(workerState())), + /** The open file; a new object for each attempt. */ + opened: createMemo(() => workerOpened(workerState())), + } +} diff --git a/packages/gui-plugins/src/microsoft-office/presentation.tsx b/packages/gui-plugins/src/microsoft-office/presentation.tsx index 7593ec4f683..31d2333a2cc 100644 --- a/packages/gui-plugins/src/microsoft-office/presentation.tsx +++ b/packages/gui-plugins/src/microsoft-office/presentation.tsx @@ -1,7 +1,8 @@ -import { onCleanup, Show } from "solid-js" +import { Show } from "solid-js" import { createStore } from "solid-js/store" import { Loader } from "@opencode/ui/loader" -import { createKeyed, usePlugin } from "@opencode/plugin/gui" +import { usePlugin } from "@opencode/plugin/gui" +import { createOfficeWorker, type WorkerClient } from "./office-worker" import { OfficePages, type PaintPage } from "./pages" import { paper } from "./paper" import { @@ -12,12 +13,13 @@ import { type VectorBitmap, type VectorRequest, } from "./slide-protocol" -import { createWorkerClient, movableBuffer, SupersededError, WorkerClosedError } from "./worker-rpc" +import { SupersededError, WorkerClosedError } from "./worker-rpc" import type { FileViewerProps } from "@opencode/plugin/gui/file" -type Opened = { readonly slides: readonly SlideSummary[]; readonly paint: PaintPage } +type Client = WorkerClient -type Client = ReturnType> +/** An opened deck: its worker and its slides. */ +type Opened = { readonly client: Client; readonly slides: readonly SlideSummary[] } /** * A read-only PowerPoint deck: every slide fitted to the pane and painted as it scrolls into view, with its speaker @@ -27,120 +29,95 @@ type Client = ReturnType> export default function OfficePresentation(props: FileViewerProps) { const ctx = usePlugin() - const [state, setState] = createStore<{ opened: Opened | undefined; failed: boolean[] }>({ - opened: undefined, - failed: [], - }) + // A worker that stops, such as one out of memory, takes the deck with it. + const viewer = createOfficeWorker({ + bytes: () => props.bytes, + createWorker: () => + new Worker(new URL("./presentation.worker.ts", import.meta.url), { type: "module", name: "PowerPoint preview" }), + open: async (client, buffer, signal) => { + const slides = await client.call("open", { bytes: buffer }, { transfer: [buffer], signal }) - // Syncs one deck's worker with the loaded bytes. Terminating the worker frees the engine's memory. - createKeyed( - () => props.bytes, - (bytes) => { - const controller = new AbortController() - const status = { failed: false } - - const worker = new Worker(new URL("./presentation.worker.ts", import.meta.url), { - type: "module", - name: "PowerPoint preview", - }) - - const client = createWorkerClient(worker) - - onCleanup(() => { - controller.abort() - client.close() - setState({ opened: undefined, failed: [] }) - }) - - const fail = () => { - if (controller.signal.aborted || status.failed) return - - status.failed = true - props.onError() - } - - // A worker that stops, such as one out of memory, takes the deck with it. - worker.addEventListener("error", fail) - worker.addEventListener("messageerror", fail) - - const painted = (index: number, failed: boolean) => { - if (!controller.signal.aborted) setState("failed", index, failed) - } - - // The view owns its bytes, so they move to the worker rather than being copied. - const buffer = movableBuffer(bytes) - - void client.call("open", { bytes: buffer }, { transfer: [buffer], signal: controller.signal }).then((slides) => { - if (controller.signal.aborted) return - - setState({ opened: { slides, paint: createPaint(client, painted) } }) - props.onDetails([ctx.plural("slides", slides.length)]) - }, fail) + return { value: { client, slides }, details: [ctx.plural("slides", slides.length)] } }, - ) + onDetails: (details) => props.onDetails(details), + onError: () => props.onError(), + }) return ( - - + +
+ +
+
} > - {(opened) => ( - ctx.t("slide", { number: index + 1 })} - overlay={(input) => ( - <> - - {/* Paper-coloured, like the slide itself, so a hidden slide fades the same way in every theme. */} -
- - -
-

- {ctx.t("slideFailed")} -

-
-
- - )} - footer={(index) => ( - - {(slide) => ( - - {/* Zero width and full minimum width: the slide sets the column's width, and long notes wrap to it. */} -
- - - {ctx.t("hiddenSlide")} - - - - {(notes) => ( -

- {notes()} -

- )} -
-
+ {(opened) => } +
+ ) +} + +/** One opened deck's slides. A reloaded file mounts a new one, with no slide failed. */ +function PresentationDeck(props: { opened: Opened }) { + const ctx = usePlugin() + const [failed, setFailed] = createStore([]) + const slides = () => props.opened.slides + const paint = createPaint(props.opened.client, (index, value) => setFailed(index, value)) + + return ( + ctx.t("slide", { number: index + 1 })} + overlay={(input) => ( + <> + + {/* Paper-coloured, like the slide itself, so a hidden slide fades the same way in every theme. */} +
+ + +
+

+ {ctx.t("slideFailed")} +

+
+
+ + )} + footer={(index) => ( + + {(slide) => ( + + {/* Zero width and full minimum width: the slide sets the column's width, and long notes wrap to it. */} +
+ + + {ctx.t("hiddenSlide")} + - )} + + {(notes) => ( +

+ {notes()} +

+ )} +
+
)} - /> +
)} - + /> ) } diff --git a/packages/gui-plugins/src/microsoft-office/spreadsheet.tsx b/packages/gui-plugins/src/microsoft-office/spreadsheet.tsx index 96bea4fbfde..9a20e2ba905 100644 --- a/packages/gui-plugins/src/microsoft-office/spreadsheet.tsx +++ b/packages/gui-plugins/src/microsoft-office/spreadsheet.tsx @@ -36,12 +36,14 @@ import { type Painted, } from "./sheet-paint" import type { SheetFrameRequest, SheetLayout, SheetMethods, SheetTab, SheetViewport } from "./sheet-protocol" -import { createWorkerClient, movableBuffer, SupersededError, WorkerClosedError } from "./worker-rpc" +import { createOfficeWorker, type WorkerClient } from "./office-worker" +import { SupersededError, WorkerClosedError } from "./worker-rpc" /** The workbook worker's end in the window. */ -type Client = ReturnType> +type Client = WorkerClient -type Opened = { readonly client: Client; readonly tabs: readonly SheetTab[] } +/** An opened workbook: its worker, its visible sheets and the layout of the sheet it opened on. */ +type Opened = { readonly client: Client; readonly tabs: readonly SheetTab[]; readonly layout: SheetLayout } /** The sheet on show, and the cell a link asked for when one opened it. */ type Shown = { readonly layout: SheetLayout; readonly target: CellAddr | undefined } @@ -70,80 +72,77 @@ const settleDelay = 150 /** A read-only Excel workbook with a tab per visible sheet. */ export default function OfficeSpreadsheet(props: FileViewerProps) { const ctx = usePlugin() + + const viewer = createOfficeWorker({ + bytes: () => props.bytes, + createWorker: () => new Worker(new URL("./spreadsheet.worker.ts", import.meta.url), { type: "module" }), + open: async (client, buffer, signal) => { + const opened = await client.call("open", { bytes: buffer }, { transfer: [buffer], signal }) + + if (!opened) return undefined + + return { + value: { client, tabs: opened.tabs, layout: opened.layout }, + details: [ctx.plural("sheets", opened.tabs.length)], + } + }, + onDetails: (details) => props.onDetails(details), + onError: () => props.onError(), + }) + + return ( + +
+ +
+
+ } + > + {(opened) => } + + ) +} + +/** One opened workbook: its sheet tabs and the grid of the sheet on show. A reloaded file mounts a new one. */ +function SpreadsheetWorkbook(props: { opened: Opened }) { + const ctx = usePlugin() const panel = createUniqueId() // `selecting` is the tab the user picked while its sheet opens in the worker. - const [state, setState] = createStore<{ - opened: Opened | undefined - shown: Shown | undefined - selecting: number | undefined - }>({ - opened: undefined, - shown: undefined, + const [state, setState] = createStore<{ shown: Shown; selecting: number | undefined }>({ + shown: { layout: props.opened.layout, target: undefined }, selecting: undefined, }) - // Syncs one workbook worker with the loaded bytes. Terminating it, when they change or the view closes, is what frees - // the engine's memory. - createKeyed( - () => props.bytes, - (bytes) => { - const controller = new AbortController() - const worker = new Worker(new URL("./spreadsheet.worker.ts", import.meta.url), { type: "module" }) - const client = createWorkerClient(worker) - - const crash = () => { - if (!controller.signal.aborted) props.onError() - } - - worker.addEventListener("error", crash) - worker.addEventListener("messageerror", crash) - - onCleanup(() => { - controller.abort() - client.close() - setState({ opened: undefined, shown: undefined, selecting: undefined }) - }) - - // The view owns its bytes, so they move to the worker rather than being copied. - const buffer = movableBuffer(bytes) - - void client.call("open", { bytes: buffer }, { transfer: [buffer], signal: controller.signal }).then((opened) => { - if (controller.signal.aborted) return - - if (!opened) return props.onError() - - setState({ opened: { client, tabs: opened.tabs }, shown: { layout: opened.layout, target: undefined } }) - props.onDetails([ctx.plural("sheets", opened.tabs.length)]) - }, crash) - }, - ) - - const active = () => state.selecting ?? state.shown?.layout.info.activeSheet + const active = () => state.selecting ?? state.shown.layout.info.activeSheet const picking: Picking = { controller: undefined } - const show = (index: number, target?: CellAddr) => { - const opened = state.opened + onCleanup(() => picking.controller?.abort()) - if (!opened || (index === active() && !target)) return + const show = (index: number, target?: CellAddr) => { + if (index === active() && !target) return picking.controller?.abort() // Back to the sheet on show: the pick that was opening is withdrawn, and the grid stays. - if (index === state.shown?.layout.info.activeSheet && !target) return void setState("selecting", undefined) + if (index === state.shown.layout.info.activeSheet && !target) return void setState("selecting", undefined) const controller = new AbortController() picking.controller = controller setState("selecting", index) - void opened.client.call("show", { sheet: index }, { signal: controller.signal }).then( + void props.opened.client.call("show", { sheet: index }, { signal: controller.signal }).then( (layout) => { // Replaced, not merged as a path setter would, so the grid below mounts afresh for the sheet. - if (state.opened === opened) setState({ shown: { layout, target }, selecting: undefined }) + setState({ shown: { layout, target }, selecting: undefined }) }, (error: Error) => { - if (state.opened !== opened || error instanceof WorkerClosedError) return + if (error instanceof WorkerClosedError) return // One sheet that fails to open leaves the others readable: the sheet on show stays. setState("selecting", undefined) @@ -154,14 +153,14 @@ export default function OfficeSpreadsheet(props: FileViewerProps) { // A link to a hidden or missing sheet goes nowhere, as in Excel. const navigate = (name: string, cell: CellAddr) => { - const tab = state.opened?.tabs.find((candidate) => candidate.name.toLowerCase() === name.toLowerCase()) + const tab = props.opened.tabs.find((candidate) => candidate.name.toLowerCase() === name.toLowerCase()) if (tab) show(tab.index, cell) } // The arrow keys move between the sheet tabs and open the one they reach; only the open tab is in the Tab order. const roam = (event: KeyboardEvent & { currentTarget: HTMLDivElement }) => { - const tabs = state.opened?.tabs ?? [] + const tabs = props.opened.tabs const current = tabs.findIndex((tab) => tab.index === active()) const forward = getComputedStyle(event.currentTarget).direction === "rtl" ? "ArrowLeft" : "ArrowRight" const backward = forward === "ArrowRight" ? "ArrowLeft" : "ArrowRight" @@ -190,62 +189,51 @@ export default function OfficeSpreadsheet(props: FileViewerProps) { const tabID = (index: number | undefined) => `${panel}-tab-${index}` return ( - - +
+
1 ? "tabpanel" : undefined} + aria-labelledby={props.opened.tabs.length > 1 ? tabID(state.shown.layout.info.activeSheet) : undefined} + class="flex min-h-0 flex-1" + > + {/* Each sheet gets its own grid, so its selection and scroll position start fresh. */} + + {(shown) => ( + + )} + +
+ 1}> +
+ + {(tab) => ( + + )} +
- } - > - {(opened) => ( -
-
1 ? "tabpanel" : undefined} - aria-labelledby={opened().tabs.length > 1 ? tabID(state.shown?.layout.info.activeSheet) : undefined} - class="flex min-h-0 flex-1" - > - {/* Each sheet gets its own grid, so its selection and scroll position start fresh. */} - - {(shown) => ( - - )} - -
- 1}> -
- - {(tab) => ( - - )} - -
-
-
- )} -
+ +
) } diff --git a/packages/gui-plugins/src/microsoft-office/worker-machine.test.ts b/packages/gui-plugins/src/microsoft-office/worker-machine.test.ts new file mode 100644 index 00000000000..10f3d009a97 --- /dev/null +++ b/packages/gui-plugins/src/microsoft-office/worker-machine.test.ts @@ -0,0 +1,214 @@ +import { describe, expect, test } from "bun:test" +import { + WORKER_OPEN_TIMEOUT_MS, + transitionWorker, + workerLoading, + workerOpened, + type WorkerEvent, + type WorkerState, + type WorkerTransition, +} from "./worker-machine" + +type Value = { readonly name: string } + +const bytes = new Uint8Array([1, 2, 3]) + +const reloaded = new Uint8Array([4, 5, 6]) + +const opened = (attempt: number, details?: readonly string[]): WorkerEvent => ({ + type: "open.succeeded", + attempt, + value: { name: `file ${attempt}` }, + details, +}) + +// Folds the events in order and returns the last transition. +const replay = (events: readonly WorkerEvent[], state: WorkerState = { status: "idle" }) => + events.reduce>((last, event) => transitionWorker(last.state, event), { state, effects: [] }) + +describe("transitionWorker", () => { + test("new bytes claim an attempt and start its worker with a bounded open", () => { + const result = replay([{ type: "bytes.changed", bytes }]) + + expect(result).toEqual({ + state: { status: "opening", attempt: 1 }, + effects: [{ type: "open-worker", attempt: 1, bytes, timeoutMs: WORKER_OPEN_TIMEOUT_MS }], + }) + expect(workerLoading(result.state)).toBe(true) + expect(workerOpened(result.state)).toBeUndefined() + }) + + test("a worker that crashes while opening reports the error once, not again when the open call rejects", () => { + const crashed = replay([ + { type: "bytes.changed", bytes }, + { type: "worker.crashed", attempt: 1 }, + ]) + + expect(crashed).toEqual({ + state: { status: "failed", attempt: 1 }, + effects: [{ type: "close-worker", attempt: 1 }, { type: "report-error" }], + }) + + // The worker client rejects the pending open with WorkerClosedError when the worker dies. + const rejected = transitionWorker(crashed.state, { type: "open.failed", attempt: 1 }) + + expect(rejected.state).toBe(crashed.state) + expect(rejected.effects).toEqual([]) + expect(workerLoading(crashed.state)).toBe(false) + }) + + test("an open reply that lands after the worker failed never shows the file or its details", () => { + const crashed = replay([ + { type: "bytes.changed", bytes }, + { type: "worker.crashed", attempt: 1 }, + ]) + + const late = transitionWorker(crashed.state, opened(1, ["3 slides"])) + + expect(late.state).toBe(crashed.state) + expect(late.effects).toEqual([]) + expect(workerOpened(late.state)).toBeUndefined() + }) + + test("an open reports its details and shows the file", () => { + const result = replay([{ type: "bytes.changed", bytes }, opened(1, ["2 sheets"])]) + + expect(result).toEqual({ + state: { status: "open", attempt: 1, value: { name: "file 1" } }, + effects: [ + { type: "cancel-open-timeout", attempt: 1 }, + { type: "report-details", details: ["2 sheets"] }, + ], + }) + expect(workerOpened(result.state) === result.state).toBe(true) + expect(workerLoading(result.state)).toBe(false) + expect(replay([{ type: "bytes.changed", bytes }, opened(1)]).effects).toEqual([ + { type: "cancel-open-timeout", attempt: 1 }, + ]) + }) + + test("a worker that crashes after the file showed takes it down once", () => { + const crashed = replay([{ type: "bytes.changed", bytes }, opened(1), { type: "worker.crashed", attempt: 1 }]) + + expect(crashed).toEqual({ + state: { status: "failed", attempt: 1 }, + effects: [{ type: "close-worker", attempt: 1 }, { type: "report-error" }], + }) + expect(workerOpened(crashed.state)).toBeUndefined() + + const again = transitionWorker(crashed.state, { type: "worker.crashed", attempt: 1 }) + + expect(again.state).toBe(crashed.state) + expect(again.effects).toEqual([]) + }) + + test("a file the worker cannot open, or one it hangs on, fails once and closes its worker", () => { + for (const event of [ + { type: "open.failed", attempt: 1 }, + { type: "open.timed-out", attempt: 1 }, + ] satisfies WorkerEvent[]) { + const failed = replay([{ type: "bytes.changed", bytes }, event]) + + expect(failed).toEqual({ + state: { status: "failed", attempt: 1 }, + effects: [{ type: "close-worker", attempt: 1 }, { type: "report-error" }], + }) + expect(transitionWorker(failed.state, opened(1)).state).toBe(failed.state) + expect(transitionWorker(failed.state, { type: "worker.crashed", attempt: 1 }).effects).toEqual([]) + } + }) + + test("a timeout after the file opened changes nothing", () => { + const open = replay([{ type: "bytes.changed", bytes }, opened(1)]) + const timedOut = transitionWorker(open.state, { type: "open.timed-out", attempt: 1 }) + + expect(timedOut.state).toBe(open.state) + expect(timedOut.effects).toEqual([]) + }) + + test("reloaded bytes close the previous worker, and its late results change nothing", () => { + const reloading = replay([ + { type: "bytes.changed", bytes }, + { type: "bytes.changed", bytes: reloaded }, + ]) + + expect(reloading).toEqual({ + state: { status: "opening", attempt: 2 }, + effects: [ + { type: "close-worker", attempt: 1 }, + { type: "open-worker", attempt: 2, bytes: reloaded, timeoutMs: WORKER_OPEN_TIMEOUT_MS }, + ], + }) + + for (const event of [ + opened(1), + { type: "open.failed", attempt: 1 }, + { type: "open.timed-out", attempt: 1 }, + { type: "worker.crashed", attempt: 1 }, + ] satisfies WorkerEvent[]) { + const stale = transitionWorker(reloading.state, event) + + expect(stale.state).toBe(reloading.state) + expect(stale.effects).toEqual([]) + } + + expect(transitionWorker(reloading.state, { type: "open.timed-out", attempt: 2 })).toEqual({ + state: { status: "failed", attempt: 2 }, + effects: [{ type: "close-worker", attempt: 2 }, { type: "report-error" }], + }) + }) + + test("reloading an open or failed file starts a fresh attempt", () => { + expect(replay([{ type: "bytes.changed", bytes }, opened(1), { type: "bytes.changed", bytes: reloaded }])).toEqual({ + state: { status: "opening", attempt: 2 }, + effects: [ + { type: "close-worker", attempt: 1 }, + { type: "open-worker", attempt: 2, bytes: reloaded, timeoutMs: WORKER_OPEN_TIMEOUT_MS }, + ], + }) + expect( + replay([ + { type: "bytes.changed", bytes }, + { type: "open.failed", attempt: 1 }, + { type: "bytes.changed", bytes: reloaded }, + ]), + ).toEqual({ + state: { status: "opening", attempt: 2 }, + effects: [{ type: "open-worker", attempt: 2, bytes: reloaded, timeoutMs: WORKER_OPEN_TIMEOUT_MS }], + }) + }) + + test("disposal closes the active worker and ignores everything after it", () => { + const opening = replay([{ type: "bytes.changed", bytes }, { type: "disposed" }]) + + expect(opening).toEqual({ state: { status: "disposed" }, effects: [{ type: "close-worker", attempt: 1 }] }) + expect(replay([{ type: "bytes.changed", bytes }, opened(1), { type: "disposed" }]).effects).toEqual([ + { type: "close-worker", attempt: 1 }, + ]) + expect( + replay([{ type: "bytes.changed", bytes }, { type: "open.failed", attempt: 1 }, { type: "disposed" }]).effects, + ).toEqual([]) + expect(replay([{ type: "disposed" }]).effects).toEqual([]) + + for (const event of [ + { type: "bytes.changed", bytes: reloaded }, + opened(1), + { type: "worker.crashed", attempt: 1 }, + { type: "disposed" }, + ] satisfies WorkerEvent[]) { + const after = transitionWorker(opening.state, event) + + expect(after.state).toBe(opening.state) + expect(after.effects).toEqual([]) + } + + expect(workerLoading(opening.state)).toBe(false) + }) + + test("results before any bytes change nothing", () => { + const idle: WorkerState = { status: "idle" } + + expect(transitionWorker(idle, opened(0)).state).toBe(idle) + expect(workerLoading(idle)).toBe(true) + }) +}) diff --git a/packages/gui-plugins/src/microsoft-office/worker-machine.ts b/packages/gui-plugins/src/microsoft-office/worker-machine.ts new file mode 100644 index 00000000000..21e45b239c6 --- /dev/null +++ b/packages/gui-plugins/src/microsoft-office/worker-machine.ts @@ -0,0 +1,111 @@ +/** + * How long a worker may take to open a file before the viewer gives up and the file view shows its binary placeholder. + * Generous, because a large workbook parses for seconds on a slow machine; it only bounds an engine that hangs. + */ +export const WORKER_OPEN_TIMEOUT_MS = 60_000 + +/** + * One Office viewer's worker. Each new set of bytes takes the next attempt number and a worker of its own, so a result + * or crash whose attempt the state no longer holds is stale. + */ +export type WorkerState = + /** No bytes yet. */ + | { readonly status: "idle" } + /** The attempt's worker is opening the bytes. */ + | { readonly status: "opening"; readonly attempt: number } + /** The file shows; `value` is what the viewer needs to show it. */ + | { readonly status: "open"; readonly attempt: number; readonly value: T } + /** The file could not be opened, or its worker stopped; the error was reported once. */ + | { readonly status: "failed"; readonly attempt: number } + | { readonly status: "disposed" } + +export type WorkerEvent = + /** The view received new bytes: a newly opened or reloaded file. */ + | { readonly type: "bytes.changed"; readonly bytes: Uint8Array } + /** `details` are the facts about the file the toolbar shows, when the viewer knows them at open. */ + | { + readonly type: "open.succeeded" + readonly attempt: number + readonly value: T + readonly details: readonly string[] | undefined + } + /** The worker could not open the bytes, or its open call rejected. */ + | { readonly type: "open.failed"; readonly attempt: number } + | { readonly type: "open.timed-out"; readonly attempt: number } + /** The worker raised `error` or `messageerror`: it is gone, with whatever it showed. */ + | { readonly type: "worker.crashed"; readonly attempt: number } + | { readonly type: "disposed" } + +export type WorkerEffect = + /** Starts the attempt's worker and open timeout, and opens the bytes in it. */ + | { readonly type: "open-worker"; readonly attempt: number; readonly bytes: Uint8Array; readonly timeoutMs: number } + | { readonly type: "cancel-open-timeout"; readonly attempt: number } + /** Ends the attempt's timeout, aborts its calls and terminates its worker, which frees the engine's memory. */ + | { readonly type: "close-worker"; readonly attempt: number } + | { readonly type: "report-details"; readonly details: readonly string[] } + | { readonly type: "report-error" } + +export type WorkerTransition = { readonly state: WorkerState; readonly effects: readonly WorkerEffect[] } + +const NONE: readonly WorkerEffect[] = [] + +export function transitionWorker(state: WorkerState, event: WorkerEvent): WorkerTransition { + if (state.status === "disposed") return { state, effects: NONE } + + if (event.type === "disposed") return { state: { status: "disposed" }, effects: closeActive(state) } + + if (event.type === "bytes.changed") { + const attempt = (state.status === "idle" ? 0 : state.attempt) + 1 + + return { + state: { status: "opening", attempt }, + effects: [ + ...closeActive(state), + { type: "open-worker", attempt, bytes: event.bytes, timeoutMs: WORKER_OPEN_TIMEOUT_MS }, + ], + } + } + + // A failed attempt reported its error once: the open call that rejects after a crash, or a reply after a timeout, + // changes nothing. + if (state.status === "idle" || state.status === "failed" || event.attempt !== state.attempt) + return { state, effects: NONE } + + if (event.type === "worker.crashed") + return { + state: { status: "failed", attempt: state.attempt }, + effects: [...closeActive(state), { type: "report-error" }], + } + + if (state.status !== "opening") return { state, effects: NONE } + + if (event.type === "open.succeeded") { + const settled: WorkerEffect = { type: "cancel-open-timeout", attempt: state.attempt } + + return { + state: { status: "open", attempt: state.attempt, value: event.value }, + effects: event.details ? [settled, { type: "report-details", details: event.details }] : [settled], + } + } + + return { + state: { status: "failed", attempt: state.attempt }, + effects: [{ type: "close-worker", attempt: state.attempt }, { type: "report-error" }], + } +} + +/** Whether the viewer shows its loader: until the file opens, and never once it failed. */ +export function workerLoading(state: WorkerState) { + return state.status === "idle" || state.status === "opening" +} + +/** The open file, one object per attempt, so a viewer keyed on it mounts afresh for a reloaded file. */ +export function workerOpened(state: WorkerState) { + return state.status === "open" ? state : undefined +} + +function closeActive(state: Exclude, { status: "disposed" }>): readonly WorkerEffect[] { + return state.status === "opening" || state.status === "open" + ? [{ type: "close-worker", attempt: state.attempt }] + : NONE +}