@hanifhan1f/vidstack 1.12.13

package/src/providers/google-cast/media-info.ts

@@ -0,0 +1,49 @@
+import type { Src } from '../../core/api/src-types';
+import type { MediaStreamType } from '../../core/api/types';
+import type { TextTrack } from '../../core/tracks/text/text-track';
+
+export class GoogleCastMediaInfoBuilder {
+  #info: chrome.cast.media.MediaInfo;
+
+  constructor(src: Src<string>) {
+    this.#info = new chrome.cast.media.MediaInfo(src.src, src.type);
+  }
+
+  build() {
+    return this.#info;
+  }
+
+  setStreamType(streamType: MediaStreamType) {
+    if (streamType.includes('live')) {
+      this.#info.streamType = chrome.cast.media.StreamType.LIVE;
+    } else {
+      this.#info.streamType = chrome.cast.media.StreamType.BUFFERED;
+    }
+
+    return this;
+  }
+
+  setTracks(tracks: TextTrack[]) {
+    this.#info.tracks = tracks.map(this.#buildCastTrack);
+    return this;
+  }
+
+  setMetadata(title: string, poster: string) {
+    this.#info.metadata = new chrome.cast.media.GenericMediaMetadata();
+    this.#info.metadata.title = title;
+    this.#info.metadata.images = [{ url: poster }];
+    return this;
+  }
+
+  #buildCastTrack(track: TextTrack, trackId: number) {
+    const castTrack = new chrome.cast.media.Track(trackId, chrome.cast.media.TrackType.TEXT);
+
+    castTrack.name = track.label;
+    castTrack.trackContentId = track.src!;
+    castTrack.trackContentType = 'text/vtt';
+    castTrack.language = track.language;
+    castTrack.subtype = track.kind.toUpperCase() as any;
+
+    return castTrack;
+  }
+}

package/src/providers/google-cast/provider.ts

@@ -0,0 +1,483 @@
+import { createScope, onDispose, peek } from 'maverick.js';
+import { DOMEvent, keysOf } from 'maverick.js/std';
+
+import type { MediaContext } from '../../core/api/media-context';
+import type { Src } from '../../core/api/src-types';
+import type { MediaStreamType } from '../../core/api/types';
+import { TimeRange } from '../../core/time-ranges';
+import { RAFLoop } from '../../foundation/observers/raf-loop';
+import type { MediaProviderAdapter } from '../types';
+import { GoogleCastMediaInfoBuilder } from './media-info';
+import { GoogleCastTracksManager } from './tracks';
+import {
+  getCastContext,
+  getCastErrorMessage,
+  getCastSession,
+  getCastSessionMedia,
+  hasActiveCastSession,
+  listenCastContextEvent,
+} from './utils';
+
+/**
+ * The Google Cast provider adds support for casting/streaming videos to Cast Receiver.
+ *
+ * @see {@link https://developers.google.com/cast/docs/overview}
+ * @docs {@link https://www.vidstack.io/docs/player/providers/google-cast}
+ */
+export class GoogleCastProvider implements MediaProviderAdapter {
+  protected $$PROVIDER_TYPE = 'GOOGLE_CAST';
+
+  readonly scope = createScope();
+
+  #player: cast.framework.RemotePlayer;
+  #ctx: MediaContext;
+  #tracks: GoogleCastTracksManager;
+
+  #currentSrc: Src<string> | null = null;
+  #state: RemotePlaybackState = 'disconnected';
+  #currentTime = 0;
+  #played = 0;
+  #seekableRange = new TimeRange(0, 0);
+  #timeRAF = new RAFLoop(this.#onAnimationFrame.bind(this));
+  #playerEventHandlers!: Record<string, RemotePlayerEventCallback>;
+  #reloadInfo: { src: Src; paused: boolean; time: number } | null = null;
+  #isIdle = false;
+
+  constructor(player: cast.framework.RemotePlayer, ctx: MediaContext) {
+    this.#player = player;
+    this.#ctx = ctx;
+    this.#tracks = new GoogleCastTracksManager(player, ctx, this.#onNewLocalTracks.bind(this));
+  }
+
+  get type() {
+    return 'google-cast';
+  }
+
+  get currentSrc() {
+    return this.#currentSrc;
+  }
+
+  /**
+   * The Google Cast remote player.
+   *
+   * @see {@link https://developers.google.com/cast/docs/reference/web_sender/cast.framework.RemotePlayer}
+   */
+  get player() {
+    return this.#player;
+  }
+
+  /**
+   * @see {@link https://developers.google.com/cast/docs/reference/web_sender/cast.framework.CastContext}
+   */
+  get cast() {
+    return getCastContext();
+  }
+
+  /**
+   * @see {@link https://developers.google.com/cast/docs/reference/web_sender/cast.framework.CastSession}
+   */
+  get session() {
+    return getCastSession();
+  }
+
+  /**
+   * @see {@link https://developers.google.com/cast/docs/reference/web_sender/chrome.cast.media.Media}
+   */
+  get media() {
+    return getCastSessionMedia();
+  }
+
+  /**
+   * Whether the current Google Cast session belongs to this provider.
+   */
+  get hasActiveSession() {
+    return hasActiveCastSession(this.#currentSrc);
+  }
+
+  setup() {
+    this.#attachCastContextEventListeners();
+    this.#attachCastPlayerEventListeners();
+
+    this.#tracks.setup();
+
+    this.#ctx.notify('provider-setup', this);
+  }
+
+  #attachCastContextEventListeners() {
+    listenCastContextEvent(
+      cast.framework.CastContextEventType.CAST_STATE_CHANGED,
+      this.#onCastStateChange.bind(this),
+    );
+  }
+
+  #attachCastPlayerEventListeners() {
+    const Event = cast.framework.RemotePlayerEventType,
+      handlers = {
+        [Event.IS_CONNECTED_CHANGED]: this.#onCastStateChange,
+        [Event.IS_MEDIA_LOADED_CHANGED]: this.#onMediaLoadedChange,
+        [Event.CAN_CONTROL_VOLUME_CHANGED]: this.#onCanControlVolumeChange,
+        [Event.CAN_SEEK_CHANGED]: this.#onCanSeekChange,
+        [Event.DURATION_CHANGED]: this.#onDurationChange,
+        [Event.IS_MUTED_CHANGED]: this.#onVolumeChange,
+        [Event.VOLUME_LEVEL_CHANGED]: this.#onVolumeChange,
+        [Event.IS_PAUSED_CHANGED]: this.#onPausedChange,
+        [Event.LIVE_SEEKABLE_RANGE_CHANGED]: this.#onProgress,
+        [Event.PLAYER_STATE_CHANGED]: this.#onPlayerStateChange,
+      };
+
+    this.#playerEventHandlers = handlers;
+
+    const handler = this.#onRemotePlayerEvent.bind(this);
+
+    for (const type of keysOf(handlers)) {
+      this.#player.controller!.addEventListener(type, handler);
+    }
+
+    onDispose(() => {
+      for (const type of keysOf(handlers)) {
+        this.#player.controller!.removeEventListener(type, handler);
+      }
+    });
+  }
+
+  async play() {
+    if (!this.#player.isPaused && !this.#isIdle) return;
+
+    if (this.#isIdle) {
+      await this.#reload(false, 0);
+      return;
+    }
+
+    this.#player.controller?.playOrPause();
+  }
+
+  async pause() {
+    if (this.#player.isPaused) return;
+    this.#player.controller?.playOrPause();
+  }
+
+  getMediaStatus(request: chrome.cast.media.GetStatusRequest) {
+    return new Promise((resolve, reject) => {
+      this.media?.getStatus(request, resolve, reject);
+    });
+  }
+
+  setMuted(muted: boolean) {
+    const hasChanged = (muted && !this.#player!.isMuted) || (!muted && this.#player!.isMuted);
+    if (hasChanged) this.#player.controller?.muteOrUnmute();
+  }
+
+  setCurrentTime(time: number) {
+    this.#player.currentTime = time;
+    this.#ctx.notify('seeking', time);
+    this.#player.controller?.seek();
+  }
+
+  setVolume(volume: number) {
+    this.#player.volumeLevel = volume;
+    this.#player.controller?.setVolumeLevel();
+  }
+
+  async loadSource(src: Src) {
+    if (this.#reloadInfo?.src !== src) this.#reloadInfo = null;
+
+    if (hasActiveCastSession(src)) {
+      this.#resumeSession();
+      this.#currentSrc = src as Src<string>;
+      return;
+    }
+
+    this.#ctx.notify('load-start');
+
+    const loadRequest = this.#buildLoadRequest(src as Src<string>),
+      errorCode = await this.session!.loadMedia(loadRequest);
+
+    if (errorCode) {
+      this.#currentSrc = null;
+      this.#ctx.notify('error', Error(getCastErrorMessage(errorCode)));
+      return;
+    }
+
+    this.#currentSrc = src as Src<string>;
+  }
+
+  destroy() {
+    this.#reset();
+    this.#endSession();
+  }
+
+  #reset() {
+    if (!this.#reloadInfo) {
+      this.#played = 0;
+      this.#seekableRange = new TimeRange(0, 0);
+    }
+
+    this.#timeRAF.stop();
+    this.#currentTime = 0;
+    this.#reloadInfo = null;
+  }
+
+  #resumeSession() {
+    const resumeSessionEvent = new DOMEvent('resume-session', { detail: this.session! });
+    this.#onMediaLoadedChange(resumeSessionEvent);
+
+    const { muted, volume, savedState } = this.#ctx.$state,
+      localState = savedState();
+
+    // Set time to whatever is further ahead (local/remote).
+    this.setCurrentTime(Math.max(this.#player.currentTime, localState?.currentTime ?? 0));
+
+    this.setMuted(muted());
+    this.setVolume(volume());
+
+    if (localState?.paused === false) this.play();
+  }
+
+  #endSession() {
+    this.cast.endCurrentSession(true);
+    const { remotePlaybackLoader } = this.#ctx.$state;
+    remotePlaybackLoader.set(null);
+  }
+
+  #disconnectFromReceiver() {
+    const { savedState } = this.#ctx.$state;
+
+    savedState.set({
+      paused: this.#player.isPaused,
+      currentTime: this.#player.currentTime,
+    });
+
+    this.#endSession();
+  }
+
+  #onAnimationFrame() {
+    this.#onCurrentTimeChange();
+  }
+
+  #onRemotePlayerEvent(event: cast.framework.RemotePlayerChangedEvent) {
+    this.#playerEventHandlers[event.type].call(this, event);
+  }
+
+  #onCastStateChange(
+    data: cast.framework.CastStateEventData | cast.framework.RemotePlayerChangedEvent,
+  ) {
+    const castState = this.cast.getCastState(),
+      state: RemotePlaybackState =
+        castState === cast.framework.CastState.CONNECTED
+          ? 'connected'
+          : castState === cast.framework.CastState.CONNECTING
+            ? 'connecting'
+            : 'disconnected';
+
+    if (this.#state === state) return;
+
+    const detail = { type: 'google-cast', state } as const,
+      trigger = this.#createEvent(data);
+
+    this.#state = state;
+    this.#ctx.notify('remote-playback-change', detail, trigger);
+
+    if (state === 'disconnected') {
+      this.#disconnectFromReceiver();
+    }
+  }
+
+  #onMediaLoadedChange(event: Event | cast.framework.RemotePlayerChangedEvent) {
+    const hasLoaded = !!this.#player.isMediaLoaded;
+    if (!hasLoaded) return;
+
+    const src = peek(this.#ctx.$state.source);
+
+    // Media info not available yet due to some internal issue in cast framework.
+    Promise.resolve().then(() => {
+      // Check src to avoid race condition.
+      if (src !== peek(this.#ctx.$state.source) || !this.#player.isMediaLoaded) return;
+
+      this.#reset();
+
+      const duration = this.#player.duration;
+      this.#seekableRange = new TimeRange(0, duration);
+
+      const detail = {
+          provider: this,
+          duration,
+          buffered: new TimeRange(0, 0),
+          seekable: this.#getSeekableRange(),
+        },
+        trigger = this.#createEvent(event);
+
+      this.#ctx.notify('loaded-metadata', undefined, trigger);
+      this.#ctx.notify('loaded-data', undefined, trigger);
+      this.#ctx.notify('can-play', detail, trigger);
+
+      this.#onCanControlVolumeChange();
+      this.#onCanSeekChange(event);
+
+      const { volume, muted } = this.#ctx.$state;
+      this.setVolume(volume());
+      this.setMuted(muted());
+
+      this.#timeRAF.start();
+
+      this.#tracks.syncRemoteTracks(trigger);
+      this.#tracks.syncRemoteActiveIds(trigger);
+    });
+  }
+
+  #onCanControlVolumeChange() {
+    this.#ctx.$state.canSetVolume.set(this.#player.canControlVolume);
+  }
+
+  #onCanSeekChange(event: Event | cast.framework.RemotePlayerChangedEvent) {
+    const trigger = this.#createEvent(event);
+    this.#ctx.notify('stream-type-change', this.#getStreamType(), trigger);
+  }
+
+  #getStreamType(): MediaStreamType {
+    const streamType = this.#player.mediaInfo?.streamType;
+    return streamType === chrome.cast.media.StreamType.LIVE
+      ? this.#player.canSeek
+        ? 'live:dvr'
+        : 'live'
+      : 'on-demand';
+  }
+
+  #onCurrentTimeChange() {
+    if (this.#reloadInfo) return;
+
+    const currentTime = this.#player.currentTime;
+    if (currentTime === this.#currentTime) return;
+
+    this.#ctx.notify('time-change', currentTime);
+
+    if (currentTime > this.#played) {
+      this.#played = currentTime;
+      this.#onProgress();
+    }
+
+    if (this.#ctx.$state.seeking()) {
+      this.#ctx.notify('seeked', currentTime);
+    }
+
+    this.#currentTime = currentTime;
+  }
+
+  #onDurationChange(event: cast.framework.RemotePlayerChangedEvent) {
+    // Duration will go to 0 on end as cast player state changes to idle.
+    if (!this.#player.isMediaLoaded || this.#reloadInfo) return;
+
+    const duration = this.#player.duration,
+      trigger = this.#createEvent(event);
+
+    this.#seekableRange = new TimeRange(0, duration);
+    this.#ctx.notify('duration-change', duration, trigger);
+  }
+
+  #onVolumeChange(event: cast.framework.RemotePlayerChangedEvent) {
+    if (!this.#player.isMediaLoaded) return;
+
+    const detail = {
+        muted: this.#player.isMuted,
+        volume: this.#player.volumeLevel,
+      },
+      trigger = this.#createEvent(event);
+
+    this.#ctx.notify('volume-change', detail, trigger);
+  }
+
+  #onPausedChange(event: cast.framework.RemotePlayerChangedEvent) {
+    const trigger = this.#createEvent(event);
+    if (this.#player.isPaused) {
+      this.#ctx.notify('pause', undefined, trigger);
+    } else {
+      this.#ctx.notify('play', undefined, trigger);
+    }
+  }
+
+  #onProgress(event?: cast.framework.RemotePlayerChangedEvent) {
+    const detail = {
+        seekable: this.#getSeekableRange(),
+        buffered: new TimeRange(0, this.#played),
+      },
+      trigger = event ? this.#createEvent(event) : undefined;
+
+    this.#ctx.notify('progress', detail, trigger);
+  }
+
+  #onPlayerStateChange(event: cast.framework.RemotePlayerChangedEvent) {
+    const state = this.#player.playerState,
+      PlayerState = chrome.cast.media.PlayerState;
+
+    this.#isIdle = state === PlayerState.IDLE;
+
+    // Handled in `onPausedChange`.
+    if (state === PlayerState.PAUSED) return;
+
+    const trigger = this.#createEvent(event);
+
+    switch (state) {
+      case PlayerState.PLAYING:
+        this.#ctx.notify('playing', undefined, trigger);
+        break;
+      case PlayerState.BUFFERING:
+        this.#ctx.notify('waiting', undefined, trigger);
+        break;
+      case PlayerState.IDLE:
+        this.#timeRAF.stop();
+        this.#ctx.notify('pause');
+        this.#ctx.notify('end');
+        break;
+    }
+  }
+
+  #getSeekableRange() {
+    return this.#player.liveSeekableRange
+      ? new TimeRange(this.#player.liveSeekableRange.start, this.#player.liveSeekableRange.end)
+      : this.#seekableRange;
+  }
+
+  #createEvent(detail: Event | { type: string }) {
+    return detail instanceof Event ? detail : new DOMEvent<any>(detail.type, { detail });
+  }
+
+  #buildMediaInfo(src: Src<string>) {
+    const { streamType, title, poster } = this.#ctx.$state;
+    return new GoogleCastMediaInfoBuilder(src)
+      .setMetadata(title(), poster())
+      .setStreamType(streamType())
+      .setTracks(this.#tracks.getLocalTextTracks())
+      .build();
+  }
+
+  #buildLoadRequest(src: Src<string>) {
+    const mediaInfo = this.#buildMediaInfo(src),
+      request = new chrome.cast.media.LoadRequest(mediaInfo),
+      savedState = this.#ctx.$state.savedState();
+
+    request.autoplay = (this.#reloadInfo?.paused ?? savedState?.paused) === false;
+    request.currentTime = this.#reloadInfo?.time ?? savedState?.currentTime ?? 0;
+
+    return request;
+  }
+
+  async #reload(paused: boolean, time: number) {
+    const src = peek(this.#ctx.$state.source);
+    this.#reloadInfo = { src, paused, time };
+    await this.loadSource(src);
+  }
+
+  #onNewLocalTracks() {
+    this.#reload(this.#player.isPaused, this.#player.currentTime).catch((error) => {
+      if (__DEV__) {
+        this.#ctx.logger
+          ?.errorGroup('[vidstack] cast failed to load new local tracks')
+          .labelledLog('Error', error)
+          .dispatch();
+      }
+    });
+  }
+}
+
+interface RemotePlayerEventCallback {
+  (event: cast.framework.RemotePlayerChangedEvent): void;
+}

package/src/providers/google-cast/tracks.ts

@@ -0,0 +1,170 @@
+import { effect, untrack } from 'maverick.js';
+import { listenEvent } from 'maverick.js/std';
+
+import type { MediaContext } from '../../core/api/media-context';
+import type { AudioTrack } from '../../core/tracks/audio/audio-tracks';
+import type { TextTrack, TextTrackInit } from '../../core/tracks/text/text-track';
+import { ListSymbol } from '../../foundation/list/symbols';
+import { getCastSessionMedia } from './utils';
+
+export class GoogleCastTracksManager {
+  #cast: cast.framework.RemotePlayer;
+  #ctx: MediaContext;
+  #onNewLocalTracks?: () => void;
+
+  constructor(cast: cast.framework.RemotePlayer, ctx: MediaContext, onNewLocalTracks?: () => void) {
+    this.#cast = cast;
+    this.#ctx = ctx;
+    this.#onNewLocalTracks = onNewLocalTracks;
+  }
+
+  setup() {
+    const syncRemoteActiveIds = this.syncRemoteActiveIds.bind(this);
+    listenEvent(this.#ctx.audioTracks, 'change', syncRemoteActiveIds);
+    listenEvent(this.#ctx.textTracks, 'mode-change', syncRemoteActiveIds);
+
+    effect(this.#syncLocalTracks.bind(this));
+  }
+
+  getLocalTextTracks() {
+    return this.#ctx.$state.textTracks().filter((track) => track.src && track.type === 'vtt');
+  }
+
+  #getLocalAudioTracks() {
+    return this.#ctx.$state.audioTracks();
+  }
+
+  #getRemoteTracks(type?: chrome.cast.media.TrackType) {
+    const tracks = this.#cast.mediaInfo?.tracks ?? [];
+    return type ? tracks.filter((track) => track.type === type) : tracks;
+  }
+
+  #getRemoteActiveIds(): number[] {
+    const activeIds: number[] = [],
+      activeLocalAudioTrack = this.#getLocalAudioTracks().find((track) => track.selected),
+      activeLocalTextTracks = this.getLocalTextTracks().filter((track) => track.mode === 'showing');
+
+    if (activeLocalAudioTrack) {
+      const remoteAudioTracks = this.#getRemoteTracks(chrome.cast.media.TrackType.AUDIO),
+        remoteAudioTrack = this.#findRemoteTrack(remoteAudioTracks, activeLocalAudioTrack);
+      if (remoteAudioTrack) activeIds.push(remoteAudioTrack.trackId);
+    }
+
+    if (activeLocalTextTracks?.length) {
+      const remoteTextTracks = this.#getRemoteTracks(chrome.cast.media.TrackType.TEXT);
+      if (remoteTextTracks.length) {
+        for (const localTrack of activeLocalTextTracks) {
+          const remoteTextTrack = this.#findRemoteTrack(remoteTextTracks, localTrack);
+          if (remoteTextTrack) activeIds.push(remoteTextTrack.trackId);
+        }
+      }
+    }
+
+    return activeIds;
+  }
+
+  #syncLocalTracks() {
+    const localTextTracks = this.getLocalTextTracks();
+
+    if (!this.#cast.isMediaLoaded) return;
+
+    const remoteTextTracks = this.#getRemoteTracks(chrome.cast.media.TrackType.TEXT);
+
+    // Sync local tracks with remote cast player.
+    for (const localTrack of localTextTracks) {
+      const hasRemoteTrack = this.#findRemoteTrack(remoteTextTracks, localTrack);
+      if (!hasRemoteTrack) {
+        // The Google Cast provider should send a new load request to add the new tracks.
+        untrack(() => this.#onNewLocalTracks?.());
+        break;
+      }
+    }
+  }
+
+  syncRemoteTracks(event?: Event) {
+    if (!this.#cast.isMediaLoaded) return;
+
+    const localAudioTracks = this.#getLocalAudioTracks(),
+      localTextTracks = this.getLocalTextTracks(),
+      remoteAudioTracks = this.#getRemoteTracks(chrome.cast.media.TrackType.AUDIO),
+      remoteTextTracks = this.#getRemoteTracks(chrome.cast.media.TrackType.TEXT);
+
+    // Sync remote audio tracks with local player.
+    for (const remoteAudioTrack of remoteAudioTracks) {
+      const hasLocalTrack = this.#findLocalTrack(localAudioTracks, remoteAudioTrack);
+      if (hasLocalTrack) continue;
+
+      const localAudioTrack: AudioTrack = {
+        id: remoteAudioTrack.trackId.toString(),
+        label: remoteAudioTrack.name,
+        language: remoteAudioTrack.language,
+        kind: remoteAudioTrack.subtype ?? 'main',
+        selected: false,
+      };
+
+      this.#ctx.audioTracks[ListSymbol.add](localAudioTrack, event);
+    }
+
+    // Sync remote text tracks with local player.
+    for (const remoteTextTrack of remoteTextTracks) {
+      const hasLocalTrack = this.#findLocalTrack(localTextTracks, remoteTextTrack);
+      if (hasLocalTrack) continue;
+
+      const localTextTrack: TextTrackInit = {
+        id: remoteTextTrack.trackId.toString(),
+        src: remoteTextTrack.trackContentId,
+        label: remoteTextTrack.name,
+        language: remoteTextTrack.language,
+        kind: remoteTextTrack.subtype.toLowerCase() as TextTrackKind,
+      };
+
+      this.#ctx.textTracks.add(localTextTrack, event);
+    }
+  }
+
+  syncRemoteActiveIds(event?: Event) {
+    if (!this.#cast.isMediaLoaded) return;
+
+    const activeIds = this.#getRemoteActiveIds(),
+      editRequest = new chrome.cast.media.EditTracksInfoRequest(activeIds);
+
+    this.#editTracksInfo(editRequest).catch((error) => {
+      if (__DEV__) {
+        this.#ctx.logger
+          ?.errorGroup('[vidstack] failed to edit cast tracks info')
+          .labelledLog('Edit Request', editRequest)
+          .labelledLog('Error', error)
+          .dispatch();
+      }
+    });
+  }
+
+  #editTracksInfo(request: chrome.cast.media.EditTracksInfoRequest) {
+    const media = getCastSessionMedia();
+    return new Promise((resolve, reject) => media?.editTracksInfo(request, resolve, reject));
+  }
+
+  #findLocalTrack<T extends AudioTrack | TextTrack>(
+    localTracks: T[],
+    remoteTrack: chrome.cast.media.Track,
+  ): T | undefined {
+    return localTracks.find((localTrack) => this.#isMatch(localTrack, remoteTrack));
+  }
+
+  #findRemoteTrack(
+    remoteTracks: chrome.cast.media.Track[],
+    localTrack: AudioTrack | TextTrack,
+  ): chrome.cast.media.Track | undefined {
+    return remoteTracks.find((remoteTrack) => this.#isMatch(localTrack, remoteTrack));
+  }
+
+  // Note: we can't rely on id matching because they will differ between local/remote. A local
+  // track id might not even exist.
+  #isMatch(localTrack: AudioTrack | TextTrack, remoteTrack: chrome.cast.media.Track) {
+    return (
+      remoteTrack.name === localTrack.label &&
+      remoteTrack.language === localTrack.language &&
+      remoteTrack.subtype.toLowerCase() === localTrack.kind.toLowerCase()
+    );
+  }
+}

package/src/providers/google-cast/types.ts

@@ -0,0 +1,3 @@
+export interface GoogleCastOptions extends Partial<cast.framework.CastOptions> {}
+
+export type { GoogleCastEvents } from './events';