@videojs/spf 10.0.0-beta.3 → 10.0.0-beta.30

package/dist/dom/index.d.ts

@@ -1,243 +0,0 @@
-import { a as PresentationAction, c as SourceBufferActor, d as WritableState, f as BandwidthState, l as TrackSelectionState, o as EventStream, s as loadTextTrackCues, t as SpfMedia, u as Presentation } from "../adapter-l8iJN_GI.js";
-
-//#region src/dom/features/setup-sourcebuffer.d.ts
-
-/**
- * Media track type for SourceBuffer setup.
- * Text tracks are excluded as they don't use MSE SourceBuffers.
- */
-type MediaTrackType = 'video' | 'audio';
-//#endregion
-//#region src/dom/features/load-segments.d.ts
-
-/**
- * State shape for segment loading.
- */
-interface SegmentLoadingState extends TrackSelectionState {
-  presentation?: Presentation;
-  preload?: string;
-  bandwidthState?: BandwidthState;
-  /** Current playback position in seconds. Defaults to 0 when undefined. */
-  currentTime?: number;
-  /** True once the user has initiated playback. Allows segment loading regardless of preload setting. */
-  playbackInitiated?: boolean;
-}
-/**
- * Owners shape for segment loading.
- */
-interface SegmentLoadingOwners {
-  videoBuffer?: SourceBuffer;
-  audioBuffer?: SourceBuffer;
-  videoBufferActor?: SourceBufferActor;
-  audioBufferActor?: SourceBufferActor;
-}
-/**
- * Load segments orchestration — Reactor layer.
- *
- * Sends typed load messages to a SegmentLoaderActor when relevant conditions
- * change. Uses targeted subscriptions rather than broad combineLatest so only
- * meaningful state changes trigger evaluation.
- *
- * Condition hierarchy (see SegmentLoadingKey for detail):
- *
- *   !playbackInitiated
- *     preload==='none' (or unset)  → dormant; no trigger
- *     preload==='metadata'         → trigger on transition to 'metadata'
- *     preload==='auto'             → trigger on transition to 'auto'
- *
- *   !playbackInitiated → playbackInitiated
- *     preload !== 'auto'           → trigger (message shape changes)
- *     preload === 'auto'           → suppressed (was already full-range mode;
- *                                    let segmentStart take over post-play)
- *                                    KNOWN LIMITATION: seek-before-play with
- *                                    preload='auto' is not supported — if the
- *                                    user seeks before pressing play, the
- *                                    first re-send is delayed until the next
- *                                    segment boundary crossing post-play.
- *
- *   playbackInitiated
- *     resolvedTrackId changes      → trigger
- *     segmentStart(currentTime) changes → trigger (segment boundary only)
- *
- * @example
- * const cleanup = loadSegments({ state, owners }, { type: 'video' });
- */
-declare function loadSegments({
-  state,
-  owners
-}: {
-  state: WritableState<SegmentLoadingState>;
-  owners: WritableState<SegmentLoadingOwners>;
-}, config: {
-  type: MediaTrackType;
-}): () => void;
-//#endregion
-//#region src/dom/features/track-current-time.d.ts
-/**
- * State shape for current time tracking.
- */
-interface CurrentTimeState {
-  currentTime?: number;
-}
-/**
- * Owners shape for current time tracking.
- */
-interface CurrentTimeOwners {
-  mediaElement?: HTMLMediaElement | undefined;
-}
-/**
- * Track current playback position from the media element.
- *
- * Mirrors `mediaElement.currentTime` into reactive state on:
- * - `timeupdate` — fires during playback (~4 Hz)
- * - `seeking` — fires when a seek begins; per spec, `currentTime` is
- *   already at the new position when this event dispatches, so buffer
- *   management can react immediately rather than waiting for `timeupdate`,
- *   which does not fire while paused.
- *
- * Also syncs immediately when a media element becomes available.
- *
- * @example
- * const cleanup = trackCurrentTime({ state, owners });
- */
-declare function trackCurrentTime({
-  state,
-  owners
-}: {
-  state: WritableState<CurrentTimeState>;
-  owners: WritableState<CurrentTimeOwners>;
-}): () => void;
-//#endregion
-//#region src/dom/features/track-playback-initiated.d.ts
-/**
- * State shape for playback initiation tracking.
- */
-interface PlaybackInitiatedState {
-  /** True once the user has initiated playback (play event fired). */
-  playbackInitiated?: boolean;
-  /** Current presentation — watched for URL changes to reset playbackInitiated. */
-  presentation?: {
-    url?: string;
-  };
-}
-/**
- * Owners shape for playback initiation tracking.
- */
-interface PlaybackInitiatedOwners {
-  mediaElement?: HTMLMediaElement | undefined;
-}
-/**
- * Track whether playback has been initiated by the user.
- *
- * Sets `state.playbackInitiated = true` when the media element fires a `play`
- * event (via `element.play()`, native controls, or autoplay) and simultaneously
- * dispatches `{ type: 'play' }` to the event stream so `resolvePresentation`
- * can react.
- *
- * Resets `state.playbackInitiated = false` when `presentation.url` changes,
- * so a new source with `preload="none"` won't load segments until play is
- * triggered again.
- *
- * This flag is used by `shouldLoadSegments` to allow segment loading after
- * play is initiated regardless of the initial `preload` setting — `preload`
- * is a startup hint, not a runtime gate.
- *
- * @example
- * const cleanup = trackPlaybackInitiated({ state, owners, events });
- */
-declare function trackPlaybackInitiated({
-  state,
-  owners,
-  events
-}: {
-  state: WritableState<PlaybackInitiatedState>;
-  owners: WritableState<PlaybackInitiatedOwners>;
-  events: EventStream<PresentationAction>;
-}): () => void;
-//#endregion
-//#region src/dom/features/track-playback-rate.d.ts
-/**
- * State shape for playback rate tracking.
- */
-interface PlaybackRateState {
-  playbackRate?: number;
-}
-/**
- * Owners shape for playback rate tracking.
- */
-interface PlaybackRateOwners {
-  mediaElement?: HTMLMediaElement | undefined;
-}
-/**
- * Track playback rate from the media element.
- *
- * Mirrors `mediaElement.playbackRate` into reactive state on each `ratechange`
- * event. Also syncs immediately when a media element becomes available.
- *
- * @example
- * const cleanup = trackPlaybackRate({ state, owners });
- */
-declare function trackPlaybackRate({
-  state,
-  owners
-}: {
-  state: WritableState<PlaybackRateState>;
-  owners: WritableState<PlaybackRateOwners>;
-}): () => void;
-//#endregion
-//#region src/dom/media/append-segment.d.ts
-/**
- * Segment appender helper (P11)
- *
- * Appends media segments (ArrayBuffer) to SourceBuffer.
- */
-/**
- * Append a media segment to a SourceBuffer.
- *
- * Waits for the SourceBuffer to be ready (not updating), then appends
- * the segment data. Returns a promise that resolves when append completes.
- *
- * @param sourceBuffer - The SourceBuffer to append to
- * @param segmentData - The segment data as ArrayBuffer
- * @returns Promise that resolves when append completes
- *
- * @example
- * const data = await fetch(segmentUrl).then(r => r.arrayBuffer());
- * await appendSegment(videoSourceBuffer, data);
- */
-declare function appendSegment(sourceBuffer: SourceBuffer, segmentData: ArrayBuffer): Promise<void>;
-//#endregion
-//#region src/dom/media/buffer-flusher.d.ts
-/**
- * Buffer flusher helper (P12)
- *
- * Removes a time range from a SourceBuffer to manage memory.
- */
-/**
- * Remove a time range from a SourceBuffer.
- *
- * Waits for the SourceBuffer to be ready (not updating), then removes
- * the specified range. Returns a promise that resolves when removal completes.
- *
- * @param sourceBuffer - The SourceBuffer to remove data from
- * @param start - Start of the time range to remove (seconds)
- * @param end - End of the time range to remove (seconds)
- * @returns Promise that resolves when removal completes
- *
- * @example
- * await flushBuffer(videoSourceBuffer, 0, 30);
- */
-declare function flushBuffer(sourceBuffer: SourceBuffer, start: number, end: number): Promise<void>;
-//#endregion
-//#region src/dom/text/parse-vtt-segment.d.ts
-/**
- * Parse a VTT segment using browser's native parser.
- *
- * Creates a dummy video element with a track element to leverage
- * the browser's optimized VTT parsing. Returns parsed VTTCue objects.
- */
-declare function parseVttSegment(url: string): Promise<VTTCue[]>;
-declare function destroyVttParser(): void;
-//#endregion
-export { type CurrentTimeOwners, type CurrentTimeState, type PlaybackInitiatedOwners, type PlaybackInitiatedState, type PlaybackRateOwners, type PlaybackRateState, SpfMedia, appendSegment, destroyVttParser, flushBuffer, loadSegments, loadTextTrackCues, parseVttSegment, trackCurrentTime, trackPlaybackInitiated, trackPlaybackRate };
-//# sourceMappingURL=index.d.ts.map

package/dist/dom/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/dom/features/setup-sourcebuffer.ts","../../src/dom/features/load-segments.ts","../../src/dom/features/track-current-time.ts","../../src/dom/features/track-playback-initiated.ts","../../src/dom/features/track-playback-rate.ts","../../src/dom/media/append-segment.ts","../../src/dom/media/buffer-flusher.ts","../../src/dom/text/parse-vtt-segment.ts"],"sourcesContent":[],"mappings":";;;;;;;AC+DA;AACiB,KD7CL,cAAA,GC6CK,OAAA,GAAA,OAAA;;;;;;;AAD+C,UAA/C,mBAAA,SAA4B,mBAAmB,CAAA;EAa/C,YAAA,CAAA,EAZA,YAYoB;EACrB,OAAA,CAAA,EAAA,MAAA;EACA,cAAA,CAAA,EAZG,cAYH;EACK;EACA,WAAA,CAAA,EAAA,MAAA;EAAiB;EAgItB,iBAAY,CAAA,EAAA,OAAA;;;;;AAMF,UA1IT,oBAAA,CA0IS;EAAd,WAAA,CAAA,EAzII,YAyIJ;EAEM,WAAA,CAAA,EA1IF,YA0IE;EAAc,gBAAA,CAAA,EAzIX,iBAyIW;qBAxIX;;;AC1ErB;AAOA;AA6BA;;;;;;;;;;;AClCA;AAUA;AAuBA;;;;;;;;;;;;;;ACnCA;AAOiB,iBHmMD,YAAA,CGlMC;EAAA,KAAA;EAAA;CAAgB,EAAA;EAsBjB,KAAA,EHiLL,aGjLsB,CHiLR,mBGjLQ,CAAA;EAC/B,MAAA,EHiLU,aGjLV,CHiLwB,oBGjLxB,CAAA;CACA,EAAA,MAAA,EAAA;EAEqB,IAAA,EHgLL,cGhLK;CAAd,CAAA,EAAA,GAAA,GAAA,IAAA;;;;;AJrBT;UEbiB,gBAAA;;;ADyDjB;;;AAA6C,UClD5B,iBAAA,CDkD4B;EAAmB,YAAA,CAAA,ECjD/C,gBDiD+C,GAAA,SAAA;AAahE;;;;;;;;;;;ACtEA;AAOA;AA6BA;;;AAIuB,iBAJP,gBAAA,CAIO;EAAA,KAAA;EAAA;CAAA,EAAA;EAAd,KAAA,EAAA,aAAA,CAAc,gBAAd,CAAA;EACe,MAAA,EAAd,aAAc,CAAA,iBAAA,CAAA;CAAd,CAAA,EAAA,GAAA,GAAA,IAAA;;;AF5BV;;;UGXiB,sBAAA;EFuDA;EACA,iBAAA,CAAA,EAAA,OAAA;EAEE;EAH0B,YAAA,CAAA,EAAA;IAAmB,GAAA,CAAA,EAAA,MAAA;EAa/C,CAAA;;;;;AAIqB,UE9DrB,uBAAA,CF8DqB;EAgItB,YAAA,CAAA,EE7LC,gBF6LW,GAAA,SAAA;;;;;;;;;;;;AC1M5B;AAOA;AA6BA;;;;;;;AAKuB,iBCNP,sBAAA,CDMO;EAAA,KAAA;EAAA,MAAA;EAAA;ACvCvB,CDuCuB,EAAA;SCDd,cAAc;UACb,cAAc;UACd,YAAY;AAxCtB,CAAA,CAAA,EAAiB,GAAA,GAAA,IAAA;;;;;AHWjB;UIbiB,iBAAA;;;AHyDjB;;;AAA6C,UGlD5B,kBAAA,CHkD4B;EAAmB,YAAA,CAAA,EGjD/C,gBHiD+C,GAAA,SAAA;AAahE;;;;;;;;;;iBGxCgB,iBAAA;;;AFMhB;EApCiB,KAAA,EEkCR,aFlCwB,CEkCV,iBFlCU,CAAA;EAOhB,MAAA,EE4BP,aF5BwB,CE4BV,kBF3BP,CAAA;AA4BjB,CAAA,CAAA,EAAgB,GAAA,GAAA,IAAA;;;;;;AFvBhB;;;;AC4CA;;;;;AAaA;;;;;;AAoIA;AAEI,iBI9LkB,aAAA,CJ8LlB,YAAA,EI9L8C,YJ8L9C,EAAA,WAAA,EI9LyE,WJ8LzE,CAAA,EI9LuF,OJ8LvF,CAAA,IAAA,CAAA;;;;;;AD/LJ;;;;AC4CA;;;;;AAaA;;;;;;AAoIA;AAEI,iBK9LkB,WAAA,CL8LlB,YAAA,EK9L4C,YL8L5C,EAAA,KAAA,EAAA,MAAA,EAAA,GAAA,EAAA,MAAA,CAAA,EK9LuF,OL8LvF,CAAA,IAAA,CAAA;;;;;;AD/LJ;;;iBOEgB,eAAA,eAA8B,QAAQ;AN0CrC,iBMAD,gBAAA,CAAA,CNAqB,EAAA,IAAA"}

package/dist/dom/index.js

@@ -1,38 +0,0 @@
-import "../src-DRsS_H80.js";
-import { a as trackPlaybackInitiated, c as destroyVttParser, i as appendSegment, l as parseVttSegment, o as trackCurrentTime, r as flushBuffer, s as loadTextTrackCues, t as SpfMedia, u as loadSegments } from "../adapter-CMw-rvbk.js";
-import { listen } from "@videojs/utils/dom";
-
-//#region src/dom/features/track-playback-rate.ts
-/**
-* Track playback rate from the media element.
-*
-* Mirrors `mediaElement.playbackRate` into reactive state on each `ratechange`
-* event. Also syncs immediately when a media element becomes available.
-*
-* @example
-* const cleanup = trackPlaybackRate({ state, owners });
-*/
-function trackPlaybackRate({ state, owners }) {
-	let lastMediaElement;
-	let removeListener = null;
-	const unsubscribe = owners.subscribe((currentOwners) => {
-		const { mediaElement } = currentOwners;
-		if (mediaElement === lastMediaElement) return;
-		removeListener?.();
-		removeListener = null;
-		lastMediaElement = mediaElement;
-		if (!mediaElement) return;
-		state.patch({ playbackRate: mediaElement.playbackRate });
-		removeListener = listen(mediaElement, "ratechange", () => {
-			state.patch({ playbackRate: mediaElement.playbackRate });
-		});
-	});
-	return () => {
-		removeListener?.();
-		unsubscribe();
-	};
-}
-
-//#endregion
-export { SpfMedia, appendSegment, destroyVttParser, flushBuffer, loadSegments, loadTextTrackCues, parseVttSegment, trackCurrentTime, trackPlaybackInitiated, trackPlaybackRate };
-//# sourceMappingURL=index.js.map

package/dist/dom/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":["lastMediaElement: HTMLMediaElement | undefined","removeListener: (() => void) | null"],"sources":["../../src/dom/features/track-playback-rate.ts"],"sourcesContent":["import { listen } from '@videojs/utils/dom';\nimport type { WritableState } from '../../core/state/create-state';\n\n/**\n * State shape for playback rate tracking.\n */\nexport interface PlaybackRateState {\n  playbackRate?: number;\n}\n\n/**\n * Owners shape for playback rate tracking.\n */\nexport interface PlaybackRateOwners {\n  mediaElement?: HTMLMediaElement | undefined;\n}\n\n/**\n * Check if we can track playback rate.\n *\n * Requires:\n * - mediaElement exists in owners\n */\nexport function canTrackPlaybackRate(owners: PlaybackRateOwners): boolean {\n  return !!owners.mediaElement;\n}\n\n/**\n * Track playback rate from the media element.\n *\n * Mirrors `mediaElement.playbackRate` into reactive state on each `ratechange`\n * event. Also syncs immediately when a media element becomes available.\n *\n * @example\n * const cleanup = trackPlaybackRate({ state, owners });\n */\nexport function trackPlaybackRate({\n  state,\n  owners,\n}: {\n  state: WritableState<PlaybackRateState>;\n  owners: WritableState<PlaybackRateOwners>;\n}): () => void {\n  let lastMediaElement: HTMLMediaElement | undefined;\n  let removeListener: (() => void) | null = null;\n\n  const unsubscribe = owners.subscribe((currentOwners) => {\n    const { mediaElement } = currentOwners;\n\n    if (mediaElement === lastMediaElement) return;\n\n    removeListener?.();\n    removeListener = null;\n    lastMediaElement = mediaElement;\n\n    if (!mediaElement) return;\n\n    state.patch({ playbackRate: mediaElement.playbackRate });\n\n    removeListener = listen(mediaElement, 'ratechange', () => {\n      state.patch({ playbackRate: mediaElement.playbackRate });\n    });\n  });\n\n  return () => {\n    removeListener?.();\n    unsubscribe();\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;AAoCA,SAAgB,kBAAkB,EAChC,OACA,UAIa;CACb,IAAIA;CACJ,IAAIC,iBAAsC;CAE1C,MAAM,cAAc,OAAO,WAAW,kBAAkB;EACtD,MAAM,EAAE,iBAAiB;AAEzB,MAAI,iBAAiB,iBAAkB;AAEvC,oBAAkB;AAClB,mBAAiB;AACjB,qBAAmB;AAEnB,MAAI,CAAC,aAAc;AAEnB,QAAM,MAAM,EAAE,cAAc,aAAa,cAAc,CAAC;AAExD,mBAAiB,OAAO,cAAc,oBAAoB;AACxD,SAAM,MAAM,EAAE,cAAc,aAAa,cAAc,CAAC;IACxD;GACF;AAEF,cAAa;AACX,oBAAkB;AAClB,eAAa"}

package/dist/dom/playback-engine/index.d.ts

@@ -1,2 +0,0 @@
-import { i as createPlaybackEngine, n as PlaybackEngine, r as PlaybackEngineConfig, t as SpfMedia } from "../../adapter-l8iJN_GI.js";
-export { type PlaybackEngine, type PlaybackEngineConfig, SpfMedia, createPlaybackEngine };

package/dist/dom/playback-engine/index.js

@@ -1,4 +0,0 @@
-import "../../src-DRsS_H80.js";
-import { n as createPlaybackEngine, t as SpfMedia } from "../../adapter-CMw-rvbk.js";
-
-export { SpfMedia, createPlaybackEngine };

package/dist/index.d.ts

@@ -1,13 +0,0 @@
-//#region src/index.d.ts
-/**
- * Stream Processing Framework (SPF) for Video.js 10
- *
- * Bundle size target: < 20KB (minified + gzipped)
- * Primary use case: CMAF HLS playback with Video.js v10
- *
- * @packageDocumentation
- */
-declare const VERSION = "0.1.0";
-//#endregion
-export { VERSION };
-//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;AAWA;;;;;;;cAAa,OAAA"}

package/dist/index.js

@@ -1,3 +0,0 @@
-import { t as VERSION } from "./src-DRsS_H80.js";
-
-export { VERSION };

package/dist/src-DRsS_H80.js

@@ -1,14 +0,0 @@
-//#region src/index.ts
-/**
-* Stream Processing Framework (SPF) for Video.js 10
-*
-* Bundle size target: < 20KB (minified + gzipped)
-* Primary use case: CMAF HLS playback with Video.js v10
-*
-* @packageDocumentation
-*/
-const VERSION = "0.1.0";
-
-//#endregion
-export { VERSION as t };
-//# sourceMappingURL=src-DRsS_H80.js.map

package/dist/src-DRsS_H80.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"src-DRsS_H80.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["/**\n * Stream Processing Framework (SPF) for Video.js 10\n *\n * Bundle size target: < 20KB (minified + gzipped)\n * Primary use case: CMAF HLS playback with Video.js v10\n *\n * @packageDocumentation\n */\n\n// Public API exports will be added here as features are implemented\n\nexport const VERSION = '0.1.0';\n"],"mappings":";;;;;;;;;AAWA,MAAa,UAAU"}