@scarlett-player/chromecast 0.1.0

package/dist/index.cjs

@@ -0,0 +1,319 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  chromecastPlugin: () => chromecastPlugin,
+  default: () => index_default,
+  isCastSDKLoaded: () => isCastSDKLoaded,
+  isCastSupported: () => isCastSupported,
+  loadCastSDK: () => loadCastSDK
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/cast-loader.ts
+var CAST_SDK_URL = "https://www.gstatic.com/cv/js/sender/v1/cast_sender.js?loadCastFramework=1";
+var loadPromise = null;
+function loadCastSDK() {
+  if (loadPromise) {
+    return loadPromise;
+  }
+  loadPromise = new Promise((resolve, reject) => {
+    if (isCastSDKLoaded()) {
+      resolve();
+      return;
+    }
+    if (typeof window === "undefined" || typeof document === "undefined") {
+      reject(new Error("Cast SDK requires browser environment"));
+      return;
+    }
+    window.__onGCastApiAvailable = (isAvailable) => {
+      if (isAvailable && isCastSDKLoaded()) {
+        resolve();
+      } else {
+        reject(new Error("Cast SDK reported not available"));
+      }
+    };
+    const script = document.createElement("script");
+    script.src = CAST_SDK_URL;
+    script.async = true;
+    script.onerror = () => {
+      loadPromise = null;
+      reject(new Error("Failed to load Cast SDK script"));
+    };
+    document.head.appendChild(script);
+  });
+  return loadPromise;
+}
+function isCastSDKLoaded() {
+  return !!(typeof window !== "undefined" && window.cast?.framework?.CastContext);
+}
+function isCastSupported() {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  const ua = navigator.userAgent;
+  const isChrome = /Chrome/.test(ua) && !/Edge|Edg/.test(ua);
+  const isChromium = /Chromium/.test(ua);
+  return isChrome || isChromium;
+}
+
+// src/index.ts
+function chromecastPlugin() {
+  let api;
+  let castContext = null;
+  let currentSession = null;
+  let remotePlayer = null;
+  let remotePlayerController = null;
+  let localTimeBeforeCast = 0;
+  let localSrcBeforeCast = "";
+  let castStateHandler = null;
+  let sessionStateHandler = null;
+  let remotePlayerHandler = null;
+  const initCastApi = () => {
+    if (!window.cast?.framework) {
+      api.logger.error("Cast framework not available");
+      return;
+    }
+    castContext = window.cast.framework.CastContext.getInstance();
+    castContext.setOptions({
+      receiverApplicationId: window.chrome.cast.media.DEFAULT_MEDIA_RECEIVER_APP_ID,
+      autoJoinPolicy: window.chrome.cast.AutoJoinPolicy.ORIGIN_SCOPED
+    });
+    remotePlayer = new window.cast.framework.RemotePlayer();
+    remotePlayerController = new window.cast.framework.RemotePlayerController(remotePlayer);
+    castStateHandler = handleCastStateChange;
+    sessionStateHandler = handleSessionStateChange;
+    remotePlayerHandler = handleRemotePlayerChange;
+    castContext.addEventListener(
+      window.cast.framework.CastContextEventType.CAST_STATE_CHANGED,
+      castStateHandler
+    );
+    castContext.addEventListener(
+      window.cast.framework.CastContextEventType.SESSION_STATE_CHANGED,
+      sessionStateHandler
+    );
+    remotePlayerController.addEventListener(
+      window.cast.framework.RemotePlayerEventType.ANY_CHANGE,
+      remotePlayerHandler
+    );
+    const initialState = castContext.getCastState();
+    const available = initialState !== window.cast.framework.CastState.NO_DEVICES_AVAILABLE;
+    api.setState("chromecastAvailable", available);
+    api.logger.debug("Cast API initialized", { available });
+  };
+  const handleCastStateChange = (event) => {
+    const available = event.castState !== window.cast.framework.CastState.NO_DEVICES_AVAILABLE;
+    api.setState("chromecastAvailable", available);
+    api.emit(available ? "chromecast:available" : "chromecast:unavailable", void 0);
+    api.logger.debug("Cast state changed", { castState: event.castState, available });
+  };
+  const handleSessionStateChange = (event) => {
+    const SessionState = window.cast.framework.SessionState;
+    switch (event.sessionState) {
+      case SessionState.SESSION_STARTED:
+      case SessionState.SESSION_RESUMED:
+        currentSession = castContext.getCurrentSession();
+        onSessionConnected();
+        break;
+      case SessionState.SESSION_ENDED:
+        onSessionDisconnected();
+        currentSession = null;
+        break;
+      case SessionState.SESSION_START_FAILED:
+        api.emit("chromecast:error", {
+          error: new Error("Failed to start cast session")
+        });
+        break;
+    }
+  };
+  const onSessionConnected = () => {
+    if (!currentSession) return;
+    const deviceName = currentSession.getCastDevice()?.friendlyName || "Chromecast";
+    api.setState("chromecastActive", true);
+    api.emit("chromecast:connected", { deviceName });
+    api.logger.info("Chromecast connected", { deviceName });
+    localTimeBeforeCast = api.getState("currentTime") || 0;
+    const source = api.getState("source");
+    localSrcBeforeCast = source?.src || "";
+    const video = api.container.querySelector("video");
+    if (video) {
+      video.pause();
+    }
+    if (localSrcBeforeCast) {
+      loadMediaOnCast(localSrcBeforeCast, localTimeBeforeCast);
+    }
+  };
+  const onSessionDisconnected = () => {
+    const castTime = remotePlayer?.currentTime || localTimeBeforeCast;
+    api.setState("chromecastActive", false);
+    api.emit("chromecast:disconnected", void 0);
+    api.logger.info("Chromecast disconnected", { resumeTime: castTime });
+    const video = api.container.querySelector("video");
+    if (video && castTime > 0) {
+      video.currentTime = castTime;
+      video.play().catch(() => {
+        api.logger.debug("Autoplay blocked on cast disconnect");
+      });
+    }
+  };
+  const loadMediaOnCast = async (src, startTime) => {
+    if (!currentSession || !window.chrome?.cast) return;
+    const contentType = src.includes(".m3u8") ? "application/x-mpegurl" : src.includes(".mpd") ? "application/dash+xml" : "video/mp4";
+    const mediaInfo = new window.chrome.cast.media.MediaInfo(src, contentType);
+    const request = new window.chrome.cast.media.LoadRequest(mediaInfo);
+    request.currentTime = startTime;
+    request.autoplay = true;
+    try {
+      await currentSession.loadMedia(request);
+      api.logger.debug("Media loaded on Chromecast", { src, startTime });
+    } catch (error) {
+      api.logger.error("Failed to load media on Chromecast", { error });
+      api.emit("chromecast:error", { error });
+    }
+  };
+  const handleRemotePlayerChange = () => {
+    if (!remotePlayer) return;
+    if (!api.getState("chromecastActive")) return;
+    api.setState("currentTime", remotePlayer.currentTime);
+    api.setState("duration", remotePlayer.duration);
+    api.setState("playing", !remotePlayer.isPaused);
+    api.setState("paused", remotePlayer.isPaused);
+    api.setState("volume", remotePlayer.volumeLevel);
+    api.setState("muted", remotePlayer.isMuted);
+  };
+  return {
+    id: "chromecast",
+    name: "Chromecast",
+    type: "feature",
+    version: "1.0.0",
+    async init(pluginApi) {
+      api = pluginApi;
+      api.setState("chromecastAvailable", false);
+      api.setState("chromecastActive", false);
+      if (!isCastSupported()) {
+        api.logger.debug("Chromecast not supported in this browser");
+        return;
+      }
+      try {
+        await loadCastSDK();
+        initCastApi();
+        api.logger.debug("Chromecast plugin initialized");
+      } catch (error) {
+        api.logger.warn("Failed to load Cast SDK", { error });
+        api.emit("chromecast:error", { error });
+      }
+    },
+    async destroy() {
+      if (currentSession) {
+        try {
+          currentSession.endSession(true);
+        } catch {
+        }
+      }
+      if (castContext && castStateHandler) {
+        castContext.removeEventListener(
+          window.cast.framework.CastContextEventType.CAST_STATE_CHANGED,
+          castStateHandler
+        );
+      }
+      if (castContext && sessionStateHandler) {
+        castContext.removeEventListener(
+          window.cast.framework.CastContextEventType.SESSION_STATE_CHANGED,
+          sessionStateHandler
+        );
+      }
+      if (remotePlayerController && remotePlayerHandler) {
+        remotePlayerController.removeEventListener(
+          window.cast.framework.RemotePlayerEventType.ANY_CHANGE,
+          remotePlayerHandler
+        );
+      }
+      castContext = null;
+      currentSession = null;
+      remotePlayer = null;
+      remotePlayerController = null;
+      castStateHandler = null;
+      sessionStateHandler = null;
+      remotePlayerHandler = null;
+      api.logger.debug("Chromecast plugin destroyed");
+    },
+    // Public methods
+    async requestSession() {
+      if (!castContext) {
+        api?.logger.warn("Cast not available");
+        return;
+      }
+      await castContext.requestSession();
+    },
+    endSession() {
+      if (currentSession) {
+        currentSession.endSession(true);
+      }
+    },
+    isAvailable() {
+      return api?.getState("chromecastAvailable") === true;
+    },
+    isConnected() {
+      return api?.getState("chromecastActive") === true;
+    },
+    getDeviceName() {
+      if (!currentSession) return null;
+      return currentSession.getCastDevice()?.friendlyName || null;
+    },
+    play() {
+      if (remotePlayer?.isPaused && remotePlayerController) {
+        remotePlayerController.playOrPause();
+      }
+    },
+    pause() {
+      if (remotePlayer && !remotePlayer.isPaused && remotePlayerController) {
+        remotePlayerController.playOrPause();
+      }
+    },
+    seek(time) {
+      if (remotePlayer && remotePlayerController) {
+        remotePlayer.currentTime = time;
+        remotePlayerController.seek();
+      }
+    },
+    setVolume(level) {
+      if (remotePlayer && remotePlayerController) {
+        remotePlayer.volumeLevel = Math.max(0, Math.min(1, level));
+        remotePlayerController.setVolumeLevel();
+      }
+    },
+    setMuted(muted) {
+      if (remotePlayer && remotePlayerController) {
+        if (remotePlayer.isMuted !== muted) {
+          remotePlayerController.muteOrUnmute();
+        }
+      }
+    }
+  };
+}
+var index_default = chromecastPlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  chromecastPlugin,
+  isCastSDKLoaded,
+  isCastSupported,
+  loadCastSDK
+});

package/dist/index.d.cts

@@ -0,0 +1,234 @@
+import { Plugin } from '@scarlett-player/core';
+
+/**
+ * Chromecast Plugin Types
+ *
+ * Minimal type definitions for Google Cast SDK.
+ * These cover the subset of the API we actually use.
+ */
+
+/** Chrome cast media types */
+declare namespace ChromeCastMedia {
+    interface MediaInfo {
+        contentId: string;
+        contentType: string;
+        streamType?: string;
+        metadata?: object;
+    }
+    interface LoadRequest {
+        mediaInfo: MediaInfo;
+        autoplay: boolean;
+        currentTime: number;
+    }
+    interface Media {
+        getEstimatedTime(): number;
+        playerState: string;
+    }
+}
+/** Cast framework namespace */
+declare namespace CastFramework {
+    interface CastContext {
+        getInstance(): CastContext;
+        setOptions(options: CastOptions): void;
+        addEventListener(type: CastContextEventType, handler: (event: CastStateEventData | SessionStateEventData) => void): void;
+        removeEventListener(type: CastContextEventType, handler: (event: CastStateEventData | SessionStateEventData) => void): void;
+        requestSession(): Promise<void>;
+        getCurrentSession(): CastSession | null;
+        endCurrentSession(stopCasting: boolean): void;
+        getCastState(): CastState;
+    }
+    interface CastOptions {
+        receiverApplicationId: string;
+        autoJoinPolicy: string;
+    }
+    interface CastSession {
+        getSessionId(): string;
+        getCastDevice(): CastDevice;
+        loadMedia(request: ChromeCastMedia.LoadRequest): Promise<void>;
+        endSession(stopCasting: boolean): void;
+        getMediaSession(): ChromeCastMedia.Media | null;
+    }
+    interface CastDevice {
+        friendlyName: string;
+        deviceId: string;
+    }
+    interface RemotePlayer {
+        currentTime: number;
+        duration: number;
+        isPaused: boolean;
+        isMediaLoaded: boolean;
+        volumeLevel: number;
+        isMuted: boolean;
+        playerState: string;
+    }
+    interface RemotePlayerController {
+        addEventListener(type: RemotePlayerEventType, handler: (event: RemotePlayerChangedEvent) => void): void;
+        removeEventListener(type: RemotePlayerEventType, handler: (event: RemotePlayerChangedEvent) => void): void;
+        playOrPause(): void;
+        stop(): void;
+        seek(): void;
+        setVolumeLevel(): void;
+        muteOrUnmute(): void;
+    }
+    interface CastStateEventData {
+        castState: CastState;
+    }
+    interface SessionStateEventData {
+        sessionState: SessionState;
+        session?: CastSession;
+    }
+    interface RemotePlayerChangedEvent {
+        field: string;
+        value: unknown;
+    }
+    enum CastContextEventType {
+        CAST_STATE_CHANGED = "caststatechanged",
+        SESSION_STATE_CHANGED = "sessionstatechanged"
+    }
+    enum RemotePlayerEventType {
+        ANY_CHANGE = "anyChanged",
+        IS_CONNECTED_CHANGED = "isConnectedChanged",
+        IS_MEDIA_LOADED_CHANGED = "isMediaLoadedChanged",
+        CURRENT_TIME_CHANGED = "currentTimeChanged",
+        DURATION_CHANGED = "durationChanged",
+        IS_PAUSED_CHANGED = "isPausedChanged",
+        VOLUME_LEVEL_CHANGED = "volumeLevelChanged",
+        IS_MUTED_CHANGED = "isMutedChanged"
+    }
+    enum CastState {
+        NO_DEVICES_AVAILABLE = "NO_DEVICES_AVAILABLE",
+        NOT_CONNECTED = "NOT_CONNECTED",
+        CONNECTING = "CONNECTING",
+        CONNECTED = "CONNECTED"
+    }
+    enum SessionState {
+        NO_SESSION = "NO_SESSION",
+        SESSION_STARTING = "SESSION_STARTING",
+        SESSION_STARTED = "SESSION_STARTED",
+        SESSION_START_FAILED = "SESSION_START_FAILED",
+        SESSION_ENDING = "SESSION_ENDING",
+        SESSION_ENDED = "SESSION_ENDED",
+        SESSION_RESUMED = "SESSION_RESUMED"
+    }
+}
+declare global {
+    interface Window {
+        __onGCastApiAvailable?: (isAvailable: boolean) => void;
+        cast?: {
+            framework: {
+                CastContext: {
+                    getInstance(): CastFramework.CastContext;
+                };
+                RemotePlayer: new () => CastFramework.RemotePlayer;
+                RemotePlayerController: new (player: CastFramework.RemotePlayer) => CastFramework.RemotePlayerController;
+                CastContextEventType: typeof CastFramework.CastContextEventType;
+                RemotePlayerEventType: typeof CastFramework.RemotePlayerEventType;
+                CastState: typeof CastFramework.CastState;
+                SessionState: typeof CastFramework.SessionState;
+            };
+        };
+        chrome?: {
+            cast: {
+                media: {
+                    DEFAULT_MEDIA_RECEIVER_APP_ID: string;
+                    MediaInfo: new (contentId: string, contentType: string) => ChromeCastMedia.MediaInfo;
+                    LoadRequest: new (mediaInfo: ChromeCastMedia.MediaInfo) => ChromeCastMedia.LoadRequest;
+                };
+                AutoJoinPolicy: {
+                    ORIGIN_SCOPED: string;
+                    TAB_AND_ORIGIN_SCOPED: string;
+                    PAGE_SCOPED: string;
+                };
+            };
+        };
+    }
+}
+/** Chromecast plugin interface */
+interface IChromecastPlugin extends Plugin {
+    readonly id: 'chromecast';
+    /** Request a cast session (opens device picker) */
+    requestSession(): Promise<void>;
+    /** End the current cast session */
+    endSession(): void;
+    /** Check if Chromecast devices are available */
+    isAvailable(): boolean;
+    /** Check if currently connected to a Chromecast */
+    isConnected(): boolean;
+    /** Get the connected device name */
+    getDeviceName(): string | null;
+    /** Play on cast device */
+    play(): void;
+    /** Pause on cast device */
+    pause(): void;
+    /** Seek on cast device */
+    seek(time: number): void;
+    /** Set volume on cast device (0-1) */
+    setVolume(level: number): void;
+    /** Mute/unmute cast device */
+    setMuted(muted: boolean): void;
+}
+/** Chromecast error event payload */
+interface ChromecastErrorEvent {
+    error: Error;
+    code?: string;
+}
+/** Chromecast connected event payload */
+interface ChromecastConnectedEvent {
+    deviceName: string;
+}
+
+/**
+ * Cast SDK Loader
+ *
+ * Dynamically loads the Google Cast SDK.
+ */
+/**
+ * Load the Google Cast SDK.
+ *
+ * Returns a promise that resolves when the SDK is ready.
+ * Safe to call multiple times - will return the same promise.
+ *
+ * @returns Promise that resolves when SDK is loaded
+ */
+declare function loadCastSDK(): Promise<void>;
+/**
+ * Check if Cast SDK is already loaded and available.
+ */
+declare function isCastSDKLoaded(): boolean;
+/**
+ * Check if Cast is supported in current environment.
+ * Chrome and Chromium-based browsers support Cast.
+ */
+declare function isCastSupported(): boolean;
+
+/**
+ * Chromecast Plugin for Scarlett Player
+ *
+ * Enables casting video to Chromecast devices using Google Cast SDK.
+ * SDK is loaded dynamically when plugin initializes.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Create a Chromecast plugin instance.
+ *
+ * @example
+ * ```ts
+ * import { chromecastPlugin } from '@scarlett-player/chromecast';
+ *
+ * const player = new ScarlettPlayer({
+ *   container: '#player',
+ *   plugins: [chromecastPlugin()],
+ * });
+ *
+ * // Request cast session
+ * const chromecast = player.getPlugin<IChromecastPlugin>('chromecast');
+ * if (chromecast?.isAvailable()) {
+ *   await chromecast.requestSession();
+ * }
+ * ```
+ */
+declare function chromecastPlugin(): IChromecastPlugin;
+
+export { type ChromecastConnectedEvent, type ChromecastErrorEvent, type IChromecastPlugin, chromecastPlugin, chromecastPlugin as default, isCastSDKLoaded, isCastSupported, loadCastSDK };

package/dist/index.d.ts

@@ -0,0 +1,234 @@
+import { Plugin } from '@scarlett-player/core';
+
+/**
+ * Chromecast Plugin Types
+ *
+ * Minimal type definitions for Google Cast SDK.
+ * These cover the subset of the API we actually use.
+ */
+
+/** Chrome cast media types */
+declare namespace ChromeCastMedia {
+    interface MediaInfo {
+        contentId: string;
+        contentType: string;
+        streamType?: string;
+        metadata?: object;
+    }
+    interface LoadRequest {
+        mediaInfo: MediaInfo;
+        autoplay: boolean;
+        currentTime: number;
+    }
+    interface Media {
+        getEstimatedTime(): number;
+        playerState: string;
+    }
+}
+/** Cast framework namespace */
+declare namespace CastFramework {
+    interface CastContext {
+        getInstance(): CastContext;
+        setOptions(options: CastOptions): void;
+        addEventListener(type: CastContextEventType, handler: (event: CastStateEventData | SessionStateEventData) => void): void;
+        removeEventListener(type: CastContextEventType, handler: (event: CastStateEventData | SessionStateEventData) => void): void;
+        requestSession(): Promise<void>;
+        getCurrentSession(): CastSession | null;
+        endCurrentSession(stopCasting: boolean): void;
+        getCastState(): CastState;
+    }
+    interface CastOptions {
+        receiverApplicationId: string;
+        autoJoinPolicy: string;
+    }
+    interface CastSession {
+        getSessionId(): string;
+        getCastDevice(): CastDevice;
+        loadMedia(request: ChromeCastMedia.LoadRequest): Promise<void>;
+        endSession(stopCasting: boolean): void;
+        getMediaSession(): ChromeCastMedia.Media | null;
+    }
+    interface CastDevice {
+        friendlyName: string;
+        deviceId: string;
+    }
+    interface RemotePlayer {
+        currentTime: number;
+        duration: number;
+        isPaused: boolean;
+        isMediaLoaded: boolean;
+        volumeLevel: number;
+        isMuted: boolean;
+        playerState: string;
+    }
+    interface RemotePlayerController {
+        addEventListener(type: RemotePlayerEventType, handler: (event: RemotePlayerChangedEvent) => void): void;
+        removeEventListener(type: RemotePlayerEventType, handler: (event: RemotePlayerChangedEvent) => void): void;
+        playOrPause(): void;
+        stop(): void;
+        seek(): void;
+        setVolumeLevel(): void;
+        muteOrUnmute(): void;
+    }
+    interface CastStateEventData {
+        castState: CastState;
+    }
+    interface SessionStateEventData {
+        sessionState: SessionState;
+        session?: CastSession;
+    }
+    interface RemotePlayerChangedEvent {
+        field: string;
+        value: unknown;
+    }
+    enum CastContextEventType {
+        CAST_STATE_CHANGED = "caststatechanged",
+        SESSION_STATE_CHANGED = "sessionstatechanged"
+    }
+    enum RemotePlayerEventType {
+        ANY_CHANGE = "anyChanged",
+        IS_CONNECTED_CHANGED = "isConnectedChanged",
+        IS_MEDIA_LOADED_CHANGED = "isMediaLoadedChanged",
+        CURRENT_TIME_CHANGED = "currentTimeChanged",
+        DURATION_CHANGED = "durationChanged",
+        IS_PAUSED_CHANGED = "isPausedChanged",
+        VOLUME_LEVEL_CHANGED = "volumeLevelChanged",
+        IS_MUTED_CHANGED = "isMutedChanged"
+    }
+    enum CastState {
+        NO_DEVICES_AVAILABLE = "NO_DEVICES_AVAILABLE",
+        NOT_CONNECTED = "NOT_CONNECTED",
+        CONNECTING = "CONNECTING",
+        CONNECTED = "CONNECTED"
+    }
+    enum SessionState {
+        NO_SESSION = "NO_SESSION",
+        SESSION_STARTING = "SESSION_STARTING",
+        SESSION_STARTED = "SESSION_STARTED",
+        SESSION_START_FAILED = "SESSION_START_FAILED",
+        SESSION_ENDING = "SESSION_ENDING",
+        SESSION_ENDED = "SESSION_ENDED",
+        SESSION_RESUMED = "SESSION_RESUMED"
+    }
+}
+declare global {
+    interface Window {
+        __onGCastApiAvailable?: (isAvailable: boolean) => void;
+        cast?: {
+            framework: {
+                CastContext: {
+                    getInstance(): CastFramework.CastContext;
+                };
+                RemotePlayer: new () => CastFramework.RemotePlayer;
+                RemotePlayerController: new (player: CastFramework.RemotePlayer) => CastFramework.RemotePlayerController;
+                CastContextEventType: typeof CastFramework.CastContextEventType;
+                RemotePlayerEventType: typeof CastFramework.RemotePlayerEventType;
+                CastState: typeof CastFramework.CastState;
+                SessionState: typeof CastFramework.SessionState;
+            };
+        };
+        chrome?: {
+            cast: {
+                media: {
+                    DEFAULT_MEDIA_RECEIVER_APP_ID: string;
+                    MediaInfo: new (contentId: string, contentType: string) => ChromeCastMedia.MediaInfo;
+                    LoadRequest: new (mediaInfo: ChromeCastMedia.MediaInfo) => ChromeCastMedia.LoadRequest;
+                };
+                AutoJoinPolicy: {
+                    ORIGIN_SCOPED: string;
+                    TAB_AND_ORIGIN_SCOPED: string;
+                    PAGE_SCOPED: string;
+                };
+            };
+        };
+    }
+}
+/** Chromecast plugin interface */
+interface IChromecastPlugin extends Plugin {
+    readonly id: 'chromecast';
+    /** Request a cast session (opens device picker) */
+    requestSession(): Promise<void>;
+    /** End the current cast session */
+    endSession(): void;
+    /** Check if Chromecast devices are available */
+    isAvailable(): boolean;
+    /** Check if currently connected to a Chromecast */
+    isConnected(): boolean;
+    /** Get the connected device name */
+    getDeviceName(): string | null;
+    /** Play on cast device */
+    play(): void;
+    /** Pause on cast device */
+    pause(): void;
+    /** Seek on cast device */
+    seek(time: number): void;
+    /** Set volume on cast device (0-1) */
+    setVolume(level: number): void;
+    /** Mute/unmute cast device */
+    setMuted(muted: boolean): void;
+}
+/** Chromecast error event payload */
+interface ChromecastErrorEvent {
+    error: Error;
+    code?: string;
+}
+/** Chromecast connected event payload */
+interface ChromecastConnectedEvent {
+    deviceName: string;
+}
+
+/**
+ * Cast SDK Loader
+ *
+ * Dynamically loads the Google Cast SDK.
+ */
+/**
+ * Load the Google Cast SDK.
+ *
+ * Returns a promise that resolves when the SDK is ready.
+ * Safe to call multiple times - will return the same promise.
+ *
+ * @returns Promise that resolves when SDK is loaded
+ */
+declare function loadCastSDK(): Promise<void>;
+/**
+ * Check if Cast SDK is already loaded and available.
+ */
+declare function isCastSDKLoaded(): boolean;
+/**
+ * Check if Cast is supported in current environment.
+ * Chrome and Chromium-based browsers support Cast.
+ */
+declare function isCastSupported(): boolean;
+
+/**
+ * Chromecast Plugin for Scarlett Player
+ *
+ * Enables casting video to Chromecast devices using Google Cast SDK.
+ * SDK is loaded dynamically when plugin initializes.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Create a Chromecast plugin instance.
+ *
+ * @example
+ * ```ts
+ * import { chromecastPlugin } from '@scarlett-player/chromecast';
+ *
+ * const player = new ScarlettPlayer({
+ *   container: '#player',
+ *   plugins: [chromecastPlugin()],
+ * });
+ *
+ * // Request cast session
+ * const chromecast = player.getPlugin<IChromecastPlugin>('chromecast');
+ * if (chromecast?.isAvailable()) {
+ *   await chromecast.requestSession();
+ * }
+ * ```
+ */
+declare function chromecastPlugin(): IChromecastPlugin;
+
+export { type ChromecastConnectedEvent, type ChromecastErrorEvent, type IChromecastPlugin, chromecastPlugin, chromecastPlugin as default, isCastSDKLoaded, isCastSupported, loadCastSDK };

package/dist/index.js

@@ -0,0 +1,289 @@
+// src/cast-loader.ts
+var CAST_SDK_URL = "https://www.gstatic.com/cv/js/sender/v1/cast_sender.js?loadCastFramework=1";
+var loadPromise = null;
+function loadCastSDK() {
+  if (loadPromise) {
+    return loadPromise;
+  }
+  loadPromise = new Promise((resolve, reject) => {
+    if (isCastSDKLoaded()) {
+      resolve();
+      return;
+    }
+    if (typeof window === "undefined" || typeof document === "undefined") {
+      reject(new Error("Cast SDK requires browser environment"));
+      return;
+    }
+    window.__onGCastApiAvailable = (isAvailable) => {
+      if (isAvailable && isCastSDKLoaded()) {
+        resolve();
+      } else {
+        reject(new Error("Cast SDK reported not available"));
+      }
+    };
+    const script = document.createElement("script");
+    script.src = CAST_SDK_URL;
+    script.async = true;
+    script.onerror = () => {
+      loadPromise = null;
+      reject(new Error("Failed to load Cast SDK script"));
+    };
+    document.head.appendChild(script);
+  });
+  return loadPromise;
+}
+function isCastSDKLoaded() {
+  return !!(typeof window !== "undefined" && window.cast?.framework?.CastContext);
+}
+function isCastSupported() {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  const ua = navigator.userAgent;
+  const isChrome = /Chrome/.test(ua) && !/Edge|Edg/.test(ua);
+  const isChromium = /Chromium/.test(ua);
+  return isChrome || isChromium;
+}
+
+// src/index.ts
+function chromecastPlugin() {
+  let api;
+  let castContext = null;
+  let currentSession = null;
+  let remotePlayer = null;
+  let remotePlayerController = null;
+  let localTimeBeforeCast = 0;
+  let localSrcBeforeCast = "";
+  let castStateHandler = null;
+  let sessionStateHandler = null;
+  let remotePlayerHandler = null;
+  const initCastApi = () => {
+    if (!window.cast?.framework) {
+      api.logger.error("Cast framework not available");
+      return;
+    }
+    castContext = window.cast.framework.CastContext.getInstance();
+    castContext.setOptions({
+      receiverApplicationId: window.chrome.cast.media.DEFAULT_MEDIA_RECEIVER_APP_ID,
+      autoJoinPolicy: window.chrome.cast.AutoJoinPolicy.ORIGIN_SCOPED
+    });
+    remotePlayer = new window.cast.framework.RemotePlayer();
+    remotePlayerController = new window.cast.framework.RemotePlayerController(remotePlayer);
+    castStateHandler = handleCastStateChange;
+    sessionStateHandler = handleSessionStateChange;
+    remotePlayerHandler = handleRemotePlayerChange;
+    castContext.addEventListener(
+      window.cast.framework.CastContextEventType.CAST_STATE_CHANGED,
+      castStateHandler
+    );
+    castContext.addEventListener(
+      window.cast.framework.CastContextEventType.SESSION_STATE_CHANGED,
+      sessionStateHandler
+    );
+    remotePlayerController.addEventListener(
+      window.cast.framework.RemotePlayerEventType.ANY_CHANGE,
+      remotePlayerHandler
+    );
+    const initialState = castContext.getCastState();
+    const available = initialState !== window.cast.framework.CastState.NO_DEVICES_AVAILABLE;
+    api.setState("chromecastAvailable", available);
+    api.logger.debug("Cast API initialized", { available });
+  };
+  const handleCastStateChange = (event) => {
+    const available = event.castState !== window.cast.framework.CastState.NO_DEVICES_AVAILABLE;
+    api.setState("chromecastAvailable", available);
+    api.emit(available ? "chromecast:available" : "chromecast:unavailable", void 0);
+    api.logger.debug("Cast state changed", { castState: event.castState, available });
+  };
+  const handleSessionStateChange = (event) => {
+    const SessionState = window.cast.framework.SessionState;
+    switch (event.sessionState) {
+      case SessionState.SESSION_STARTED:
+      case SessionState.SESSION_RESUMED:
+        currentSession = castContext.getCurrentSession();
+        onSessionConnected();
+        break;
+      case SessionState.SESSION_ENDED:
+        onSessionDisconnected();
+        currentSession = null;
+        break;
+      case SessionState.SESSION_START_FAILED:
+        api.emit("chromecast:error", {
+          error: new Error("Failed to start cast session")
+        });
+        break;
+    }
+  };
+  const onSessionConnected = () => {
+    if (!currentSession) return;
+    const deviceName = currentSession.getCastDevice()?.friendlyName || "Chromecast";
+    api.setState("chromecastActive", true);
+    api.emit("chromecast:connected", { deviceName });
+    api.logger.info("Chromecast connected", { deviceName });
+    localTimeBeforeCast = api.getState("currentTime") || 0;
+    const source = api.getState("source");
+    localSrcBeforeCast = source?.src || "";
+    const video = api.container.querySelector("video");
+    if (video) {
+      video.pause();
+    }
+    if (localSrcBeforeCast) {
+      loadMediaOnCast(localSrcBeforeCast, localTimeBeforeCast);
+    }
+  };
+  const onSessionDisconnected = () => {
+    const castTime = remotePlayer?.currentTime || localTimeBeforeCast;
+    api.setState("chromecastActive", false);
+    api.emit("chromecast:disconnected", void 0);
+    api.logger.info("Chromecast disconnected", { resumeTime: castTime });
+    const video = api.container.querySelector("video");
+    if (video && castTime > 0) {
+      video.currentTime = castTime;
+      video.play().catch(() => {
+        api.logger.debug("Autoplay blocked on cast disconnect");
+      });
+    }
+  };
+  const loadMediaOnCast = async (src, startTime) => {
+    if (!currentSession || !window.chrome?.cast) return;
+    const contentType = src.includes(".m3u8") ? "application/x-mpegurl" : src.includes(".mpd") ? "application/dash+xml" : "video/mp4";
+    const mediaInfo = new window.chrome.cast.media.MediaInfo(src, contentType);
+    const request = new window.chrome.cast.media.LoadRequest(mediaInfo);
+    request.currentTime = startTime;
+    request.autoplay = true;
+    try {
+      await currentSession.loadMedia(request);
+      api.logger.debug("Media loaded on Chromecast", { src, startTime });
+    } catch (error) {
+      api.logger.error("Failed to load media on Chromecast", { error });
+      api.emit("chromecast:error", { error });
+    }
+  };
+  const handleRemotePlayerChange = () => {
+    if (!remotePlayer) return;
+    if (!api.getState("chromecastActive")) return;
+    api.setState("currentTime", remotePlayer.currentTime);
+    api.setState("duration", remotePlayer.duration);
+    api.setState("playing", !remotePlayer.isPaused);
+    api.setState("paused", remotePlayer.isPaused);
+    api.setState("volume", remotePlayer.volumeLevel);
+    api.setState("muted", remotePlayer.isMuted);
+  };
+  return {
+    id: "chromecast",
+    name: "Chromecast",
+    type: "feature",
+    version: "1.0.0",
+    async init(pluginApi) {
+      api = pluginApi;
+      api.setState("chromecastAvailable", false);
+      api.setState("chromecastActive", false);
+      if (!isCastSupported()) {
+        api.logger.debug("Chromecast not supported in this browser");
+        return;
+      }
+      try {
+        await loadCastSDK();
+        initCastApi();
+        api.logger.debug("Chromecast plugin initialized");
+      } catch (error) {
+        api.logger.warn("Failed to load Cast SDK", { error });
+        api.emit("chromecast:error", { error });
+      }
+    },
+    async destroy() {
+      if (currentSession) {
+        try {
+          currentSession.endSession(true);
+        } catch {
+        }
+      }
+      if (castContext && castStateHandler) {
+        castContext.removeEventListener(
+          window.cast.framework.CastContextEventType.CAST_STATE_CHANGED,
+          castStateHandler
+        );
+      }
+      if (castContext && sessionStateHandler) {
+        castContext.removeEventListener(
+          window.cast.framework.CastContextEventType.SESSION_STATE_CHANGED,
+          sessionStateHandler
+        );
+      }
+      if (remotePlayerController && remotePlayerHandler) {
+        remotePlayerController.removeEventListener(
+          window.cast.framework.RemotePlayerEventType.ANY_CHANGE,
+          remotePlayerHandler
+        );
+      }
+      castContext = null;
+      currentSession = null;
+      remotePlayer = null;
+      remotePlayerController = null;
+      castStateHandler = null;
+      sessionStateHandler = null;
+      remotePlayerHandler = null;
+      api.logger.debug("Chromecast plugin destroyed");
+    },
+    // Public methods
+    async requestSession() {
+      if (!castContext) {
+        api?.logger.warn("Cast not available");
+        return;
+      }
+      await castContext.requestSession();
+    },
+    endSession() {
+      if (currentSession) {
+        currentSession.endSession(true);
+      }
+    },
+    isAvailable() {
+      return api?.getState("chromecastAvailable") === true;
+    },
+    isConnected() {
+      return api?.getState("chromecastActive") === true;
+    },
+    getDeviceName() {
+      if (!currentSession) return null;
+      return currentSession.getCastDevice()?.friendlyName || null;
+    },
+    play() {
+      if (remotePlayer?.isPaused && remotePlayerController) {
+        remotePlayerController.playOrPause();
+      }
+    },
+    pause() {
+      if (remotePlayer && !remotePlayer.isPaused && remotePlayerController) {
+        remotePlayerController.playOrPause();
+      }
+    },
+    seek(time) {
+      if (remotePlayer && remotePlayerController) {
+        remotePlayer.currentTime = time;
+        remotePlayerController.seek();
+      }
+    },
+    setVolume(level) {
+      if (remotePlayer && remotePlayerController) {
+        remotePlayer.volumeLevel = Math.max(0, Math.min(1, level));
+        remotePlayerController.setVolumeLevel();
+      }
+    },
+    setMuted(muted) {
+      if (remotePlayer && remotePlayerController) {
+        if (remotePlayer.isMuted !== muted) {
+          remotePlayerController.muteOrUnmute();
+        }
+      }
+    }
+  };
+}
+var index_default = chromecastPlugin;
+export {
+  chromecastPlugin,
+  index_default as default,
+  isCastSDKLoaded,
+  isCastSupported,
+  loadCastSDK
+};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@scarlett-player/chromecast",
+  "version": "0.1.0",
+  "description": "Chromecast Plugin for Scarlett Player",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "dev": "tsup src/index.ts --format esm,cjs --dts --watch",
+    "test": "vitest --run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest --coverage"
+  },
+  "peerDependencies": {
+    "@scarlett-player/core": "^0.1.0"
+  },
+  "devDependencies": {
+    "@scarlett-player/core": "file:../../core",
+    "typescript": "^5.3.0",
+    "tsup": "^8.0.0",
+    "vitest": "^1.6.0",
+    "@vitest/coverage-v8": "^1.6.0",
+    "jsdom": "^24.0.0"
+  },
+  "keywords": [
+    "video",
+    "player",
+    "chromecast",
+    "casting",
+    "google-cast",
+    "scarlett"
+  ],
+  "author": "The Stream Platform",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Hackney-Enterprises-Inc/scarlett-player.git",
+    "directory": "packages/plugins/chromecast"
+  },
+  "bugs": {
+    "url": "https://github.com/Hackney-Enterprises-Inc/scarlett-player/issues"
+  },
+  "homepage": "https://github.com/Hackney-Enterprises-Inc/scarlett-player#readme"
+}