ogplayer 0.2.1 → 1.0.0

package/dist/core/player.d.ts

@@ -155,7 +155,52 @@ export declare class OGPlayer {
     removeAdListener(l: AdListener): void;
     private dispatch;
     private emit;
+    /** The queue set by loadPlaylist() — empty when a single item was loaded. */
+    private playlistItems;
+    private playlistPosition;
+    /** Content ended with the item's ad schedule not yet settled (postroll
+     * still to play, or the VMAP still loading after an early seek-to-end).
+     * The playlist advance waits for all-ads-completed / an ad error, with a
+     * timeout so a hung ads request can never wedge the queue. */
+    private pendingPlaylistAdvanceAfterAds;
+    private playlistAdvanceFallback;
+    /** False from the moment an ad session actually starts for the current
+     * item until the provider reports all ads completed — the playlist
+     * advance gate. True when the item has no session (or a watched one).
+     * Works for every provider (IMA and FreeWheel alike), unlike a cue-point
+     * or session-key heuristic. */
+    private adScheduleSettled;
+    get playlist(): OGMediaItem[];
+    /** Index of the playing item within the playlist (−1 without one). */
+    get currentPlaylistIndex(): number;
+    /** The item that plays after the current one — null on the last item or
+     * without a playlist. The UI's "Up next" card keys off this. */
+    get nextPlaylistItem(): OGMediaItem | null;
+    /** Loads a single item, clearing any playlist set earlier. */
     load(item: OGMediaItem, options?: LoadOptions): void;
+    /**
+     * Queues `items` and starts playback at `startIndex`. Each item keeps its
+     * own DRM/ads/subtitle pipeline; when one ends (postrolls included) the
+     * next loads automatically and `onPlaylistItemChanged` fires. The UI's
+     * "Up next" countdown card appears in the lead window before each advance;
+     * `skipToNext()` jumps immediately.
+     */
+    loadPlaylist(items: OGMediaItem[], options?: {
+        startIndex?: number;
+        autoplay?: boolean;
+    }): void;
+    /** Skips to the next playlist item now (the "Up next" card's tap action).
+     * No-op on the last item or without a playlist. */
+    skipToNext(): void;
+    /** Content already ended and the ad schedule just settled (all ads done
+     * or the session errored) — run the deferred playlist advance. A tick
+     * later: the advance tears down the ad session, which must not happen
+     * inside the provider's own callback. */
+    private releasePendingPlaylistAdvance;
+    /** Advances to the next queued item, if any. Called from the completion
+     * funnels (content end / postroll end) and from skipToNext(). */
+    private maybeAdvancePlaylist;
+    private loadItemInternal;
     /** Wire the media pipeline for `item` — everything about the SOURCE, none
      * of the session state. Reused to restore content after a provider that
      * plays ads in the content element (FreeWheel) hands it back. */

package/dist/core/types.d.ts

@@ -135,6 +135,14 @@ export interface PlaybackListener {
     /** The browser blocked autoplay-with-audio and `fallbackToMutedAutoplay`
      *  restarted playback muted — show your own unmute affordance. */
     onMutedAutoplayFallback?(): void;
+    /** A playlist item became current — fired for the start item of
+     *  `loadPlaylist`, every auto-advance, and every `skipToNext()`. */
+    onPlaylistItemChanged?(index: number, item: OGMediaItem): void;
+    /** The user skipped ahead via `skipToNext()` (the "Up next" card's tap) —
+     *  fired before the resulting onPlaylistItemChanged. Auto-advances at the
+     *  end of an item do NOT fire this, so analytics can tell an impatient
+     *  skip from natural completion. */
+    onPlaylistItemSkipped?(fromIndex: number, toIndex: number): void;
     onError?(error: OGPlayerError): void;
 }
 /** One frame of a storyboard/trick-play track: a crop within a sprite. */