mirror of
https://github.com/zoriya/v10.git
synced 2026-08-16 02:45:09 +00:00
65 lines
3.2 KiB
TypeScript
65 lines
3.2 KiB
TypeScript
import { Cue, Segment } from "../../media/types/index.js";
|
|
import { AnySlotMap } from "../../core/composition/create-composition.js";
|
|
//#region src/playback/primitives/text-segment-load-pipeline.d.ts
|
|
/**
|
|
* Resolves a text-track segment URL into the array of cues it contains.
|
|
*
|
|
* "Resolve" because the fn covers both network fetch and parse into the
|
|
* domain model. Host-agnostic — the concrete resolver (e.g. the
|
|
* browser's native VTT resolver) is supplied at engine-assembly time,
|
|
* so this stays DOM-free. A pure `url → cues` primitive (the text
|
|
* analog of the v/a loader's `fetchBytes`); composition-awareness lives in
|
|
* the injected {@link TextLoadStep}s, not here.
|
|
*/
|
|
type TextTrackSegmentResolver<C extends Cue = Cue> = (url: string) => Promise<C[]>;
|
|
/** Internal load-task descriptor — one segment fetch + dispatch unit. */
|
|
interface TextLoadTask {
|
|
segment: Segment;
|
|
trackId: string;
|
|
}
|
|
/**
|
|
* A text load in mid-pipeline — the text analog of the v/a loader's `Frame`.
|
|
* `resolveCuesStep` fills `cues`; `dispatchCuesStep` sends them. `metadata` is
|
|
* opaque header metadata a resolve step may attach for a later step to read
|
|
* (e.g. relocation stashes the `X-TIMESTAMP-MAP` correlation here for its rebase
|
|
* step). Typed `unknown` so the generic loader stays host-agnostic — the step
|
|
* that reads it knows its concrete shape (mirrors `StepDeps.state`).
|
|
*/
|
|
interface TextFrame<C extends Cue = Cue> {
|
|
readonly op: TextLoadTask;
|
|
cues?: C[];
|
|
metadata?: unknown;
|
|
}
|
|
/**
|
|
* One stage of a text message pipeline — the text analog of the v/a loader's
|
|
* `LoadStep`. Mutates the {@link TextFrame} in place and may be async; the runner
|
|
* checks `signal.aborted` before each step and passes the actor's
|
|
* {@link TextStepDeps} on every call, so a stateless step (`resolveCuesStep`) is a
|
|
* plain value and a step that needs composition signals (relocation's cue rebase)
|
|
* reads them from `deps` at call time.
|
|
*/
|
|
type TextLoadStep<C extends Cue = Cue> = (frame: TextFrame<C>, signal: AbortSignal, deps: TextStepDeps) => void | Promise<void>;
|
|
/**
|
|
* The uniform passthrough handed to each {@link TextLoadStep} — the composition triple,
|
|
* the text analog of `StepDeps`. `state`/`context` are the composition signal maps;
|
|
* `config` is the threaded config with the loader's wiring folded in (see
|
|
* {@link textStepWiring} + `createTextTrackSegmentLoaderActor`). Typed loose: composition
|
|
* steps read `state`; base steps read the folded wiring off `config`.
|
|
*/
|
|
interface TextStepDeps {
|
|
state: AnySlotMap;
|
|
context: AnySlotMap;
|
|
config: object;
|
|
}
|
|
/**
|
|
* Builds the ordered step list, called **once per actor** (mirrors the v/a loader's
|
|
* `MessagePipelines`, but text has a single op type so it's a flat array, not a
|
|
* `Record`). The default ({@link DEFAULT_TEXT_MESSAGE_PIPELINES}) is
|
|
* `resolveCues → dispatchCues`; a non-zero-PTS composition returns a list that
|
|
* inserts a cue-rebase step (see `relocatingTextPipelines`), so the loader stays
|
|
* oblivious to relocation.
|
|
*/
|
|
type TextMessagePipelines<C extends Cue = Cue> = () => TextLoadStep<C>[];
|
|
//#endregion
|
|
export { TextFrame, TextLoadStep, TextLoadTask, TextMessagePipelines, TextStepDeps, TextTrackSegmentResolver };
|
|
//# sourceMappingURL=text-segment-load-pipeline.d.ts.map
|