@scarlett-player/airplay 0.1.0

package/dist/index.cjs

@@ -0,0 +1,148 @@
+"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, {
+  airplayPlugin: () => airplayPlugin,
+  default: () => index_default,
+  isAirPlaySupported: () => isAirPlaySupported
+});
+module.exports = __toCommonJS(index_exports);
+function isAirPlaySupported() {
+  return typeof HTMLVideoElement !== "undefined" && typeof HTMLVideoElement.prototype.webkitShowPlaybackTargetPicker === "function";
+}
+function airplayPlugin() {
+  let api;
+  let video = null;
+  let unsubMediaLoaded = null;
+  const handleAvailabilityChange = (e) => {
+    const event = e;
+    const available = event.availability === "available";
+    api.setState("airplayAvailable", available);
+    api.emit(available ? "airplay:available" : "airplay:unavailable", void 0);
+    api.logger.debug("AirPlay availability changed", { available });
+  };
+  const handleTargetChange = () => {
+    const active = video?.webkitCurrentPlaybackTargetIsWireless === true;
+    api.setState("airplayActive", active);
+    api.emit(active ? "airplay:connected" : "airplay:disconnected", void 0);
+  };
+  const attachToVideo = () => {
+    if (video) return;
+    video = api.container.querySelector("video");
+    if (!video) {
+      api.logger.debug("AirPlay: No video element yet");
+      return;
+    }
+    api.logger.debug("AirPlay: Attaching to video element");
+    video.addEventListener(
+      "webkitplaybacktargetavailabilitychanged",
+      handleAvailabilityChange
+    );
+    video.addEventListener(
+      "webkitcurrentplaybacktargetiswirelesschanged",
+      handleTargetChange
+    );
+    if ("remote" in video && video.remote) {
+      api.logger.debug("AirPlay: RemotePlayback API available");
+      video.remote.watchAvailability((available) => {
+        api.logger.debug("AirPlay: RemotePlayback availability", { available });
+        if (available) {
+          api.setState("airplayAvailable", true);
+          api.emit("airplay:available", void 0);
+        }
+      }).catch((err) => {
+        api.logger.debug("AirPlay: RemotePlayback watchAvailability not supported", { error: err.message });
+      });
+    }
+  };
+  return {
+    id: "airplay",
+    name: "AirPlay",
+    type: "feature",
+    version: "1.0.0",
+    async init(pluginApi) {
+      api = pluginApi;
+      api.setState("airplayAvailable", false);
+      api.setState("airplayActive", false);
+      if (!isAirPlaySupported()) {
+        api.logger.debug("AirPlay not supported in this browser");
+        return;
+      }
+      attachToVideo();
+      unsubMediaLoaded = api.on("media:loaded", () => {
+        attachToVideo();
+      });
+      api.logger.debug("AirPlay plugin initialized");
+    },
+    async destroy() {
+      unsubMediaLoaded?.();
+      unsubMediaLoaded = null;
+      if (video && isAirPlaySupported()) {
+        video.removeEventListener(
+          "webkitplaybacktargetavailabilitychanged",
+          handleAvailabilityChange
+        );
+        video.removeEventListener(
+          "webkitcurrentplaybacktargetiswirelesschanged",
+          handleTargetChange
+        );
+      }
+      video = null;
+      api.logger.debug("AirPlay plugin destroyed");
+    },
+    async showPicker() {
+      if (!isAirPlaySupported()) {
+        api?.logger.warn("AirPlay not supported in this browser");
+        return;
+      }
+      if (!video) {
+        attachToVideo();
+      }
+      if (!video) {
+        api?.logger.warn("Cannot show AirPlay picker: no video element");
+        return;
+      }
+      const hlsPlugin = api?.getPlugin("hls-provider");
+      if (hlsPlugin && !hlsPlugin.isNativeHLS()) {
+        api?.logger.info("Switching to native HLS for AirPlay compatibility");
+        await hlsPlugin.switchToNative();
+        video = null;
+        attachToVideo();
+      }
+      video?.webkitShowPlaybackTargetPicker?.();
+    },
+    isAvailable() {
+      return api?.getState("airplayAvailable") === true;
+    },
+    isActive() {
+      return api?.getState("airplayActive") === true;
+    },
+    stop() {
+      api?.logger.debug("AirPlay stop requested (use system controls to disconnect)");
+    }
+  };
+}
+var index_default = airplayPlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  airplayPlugin,
+  isAirPlaySupported
+});

package/dist/index.d.cts

@@ -0,0 +1,62 @@
+import { Plugin } from '@scarlett-player/core';
+
+/**
+ * AirPlay Plugin Types
+ */
+
+/** AirPlay plugin interface */
+interface IAirPlayPlugin extends Plugin {
+    readonly id: 'airplay';
+    /** Show the AirPlay device picker (Safari only) */
+    showPicker(): void;
+    /** Check if AirPlay is available (Safari + devices found) */
+    isAvailable(): boolean;
+    /** Check if currently casting via AirPlay */
+    isActive(): boolean;
+    /** Stop AirPlay casting */
+    stop(): void;
+}
+/** AirPlay availability event */
+interface AirPlayAvailabilityEvent {
+    available: boolean;
+}
+/** AirPlay connection event */
+interface AirPlayConnectionEvent {
+    connected: boolean;
+}
+
+/**
+ * AirPlay Plugin for Scarlett Player
+ *
+ * Wraps Safari's native AirPlay APIs for wireless playback.
+ * Gracefully degrades to no-op on non-Safari browsers.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Check if AirPlay is supported (Safari only).
+ */
+declare function isAirPlaySupported(): boolean;
+/**
+ * Create an AirPlay plugin instance.
+ *
+ * @example
+ * ```ts
+ * import { airplayPlugin } from '@scarlett-player/airplay';
+ *
+ * const player = new ScarlettPlayer({
+ *   container: '#player',
+ *   plugins: [airplayPlugin()],
+ * });
+ *
+ * // Show AirPlay picker
+ * const airplay = player.getPlugin<IAirPlayPlugin>('airplay');
+ * if (airplay?.isAvailable()) {
+ *   airplay.showPicker();
+ * }
+ * ```
+ */
+declare function airplayPlugin(): IAirPlayPlugin;
+
+export { type AirPlayAvailabilityEvent, type AirPlayConnectionEvent, type IAirPlayPlugin, airplayPlugin, airplayPlugin as default, isAirPlaySupported };

package/dist/index.d.ts

@@ -0,0 +1,62 @@
+import { Plugin } from '@scarlett-player/core';
+
+/**
+ * AirPlay Plugin Types
+ */
+
+/** AirPlay plugin interface */
+interface IAirPlayPlugin extends Plugin {
+    readonly id: 'airplay';
+    /** Show the AirPlay device picker (Safari only) */
+    showPicker(): void;
+    /** Check if AirPlay is available (Safari + devices found) */
+    isAvailable(): boolean;
+    /** Check if currently casting via AirPlay */
+    isActive(): boolean;
+    /** Stop AirPlay casting */
+    stop(): void;
+}
+/** AirPlay availability event */
+interface AirPlayAvailabilityEvent {
+    available: boolean;
+}
+/** AirPlay connection event */
+interface AirPlayConnectionEvent {
+    connected: boolean;
+}
+
+/**
+ * AirPlay Plugin for Scarlett Player
+ *
+ * Wraps Safari's native AirPlay APIs for wireless playback.
+ * Gracefully degrades to no-op on non-Safari browsers.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Check if AirPlay is supported (Safari only).
+ */
+declare function isAirPlaySupported(): boolean;
+/**
+ * Create an AirPlay plugin instance.
+ *
+ * @example
+ * ```ts
+ * import { airplayPlugin } from '@scarlett-player/airplay';
+ *
+ * const player = new ScarlettPlayer({
+ *   container: '#player',
+ *   plugins: [airplayPlugin()],
+ * });
+ *
+ * // Show AirPlay picker
+ * const airplay = player.getPlugin<IAirPlayPlugin>('airplay');
+ * if (airplay?.isAvailable()) {
+ *   airplay.showPicker();
+ * }
+ * ```
+ */
+declare function airplayPlugin(): IAirPlayPlugin;
+
+export { type AirPlayAvailabilityEvent, type AirPlayConnectionEvent, type IAirPlayPlugin, airplayPlugin, airplayPlugin as default, isAirPlaySupported };

package/dist/index.js

@@ -0,0 +1,122 @@
+// src/index.ts
+function isAirPlaySupported() {
+  return typeof HTMLVideoElement !== "undefined" && typeof HTMLVideoElement.prototype.webkitShowPlaybackTargetPicker === "function";
+}
+function airplayPlugin() {
+  let api;
+  let video = null;
+  let unsubMediaLoaded = null;
+  const handleAvailabilityChange = (e) => {
+    const event = e;
+    const available = event.availability === "available";
+    api.setState("airplayAvailable", available);
+    api.emit(available ? "airplay:available" : "airplay:unavailable", void 0);
+    api.logger.debug("AirPlay availability changed", { available });
+  };
+  const handleTargetChange = () => {
+    const active = video?.webkitCurrentPlaybackTargetIsWireless === true;
+    api.setState("airplayActive", active);
+    api.emit(active ? "airplay:connected" : "airplay:disconnected", void 0);
+  };
+  const attachToVideo = () => {
+    if (video) return;
+    video = api.container.querySelector("video");
+    if (!video) {
+      api.logger.debug("AirPlay: No video element yet");
+      return;
+    }
+    api.logger.debug("AirPlay: Attaching to video element");
+    video.addEventListener(
+      "webkitplaybacktargetavailabilitychanged",
+      handleAvailabilityChange
+    );
+    video.addEventListener(
+      "webkitcurrentplaybacktargetiswirelesschanged",
+      handleTargetChange
+    );
+    if ("remote" in video && video.remote) {
+      api.logger.debug("AirPlay: RemotePlayback API available");
+      video.remote.watchAvailability((available) => {
+        api.logger.debug("AirPlay: RemotePlayback availability", { available });
+        if (available) {
+          api.setState("airplayAvailable", true);
+          api.emit("airplay:available", void 0);
+        }
+      }).catch((err) => {
+        api.logger.debug("AirPlay: RemotePlayback watchAvailability not supported", { error: err.message });
+      });
+    }
+  };
+  return {
+    id: "airplay",
+    name: "AirPlay",
+    type: "feature",
+    version: "1.0.0",
+    async init(pluginApi) {
+      api = pluginApi;
+      api.setState("airplayAvailable", false);
+      api.setState("airplayActive", false);
+      if (!isAirPlaySupported()) {
+        api.logger.debug("AirPlay not supported in this browser");
+        return;
+      }
+      attachToVideo();
+      unsubMediaLoaded = api.on("media:loaded", () => {
+        attachToVideo();
+      });
+      api.logger.debug("AirPlay plugin initialized");
+    },
+    async destroy() {
+      unsubMediaLoaded?.();
+      unsubMediaLoaded = null;
+      if (video && isAirPlaySupported()) {
+        video.removeEventListener(
+          "webkitplaybacktargetavailabilitychanged",
+          handleAvailabilityChange
+        );
+        video.removeEventListener(
+          "webkitcurrentplaybacktargetiswirelesschanged",
+          handleTargetChange
+        );
+      }
+      video = null;
+      api.logger.debug("AirPlay plugin destroyed");
+    },
+    async showPicker() {
+      if (!isAirPlaySupported()) {
+        api?.logger.warn("AirPlay not supported in this browser");
+        return;
+      }
+      if (!video) {
+        attachToVideo();
+      }
+      if (!video) {
+        api?.logger.warn("Cannot show AirPlay picker: no video element");
+        return;
+      }
+      const hlsPlugin = api?.getPlugin("hls-provider");
+      if (hlsPlugin && !hlsPlugin.isNativeHLS()) {
+        api?.logger.info("Switching to native HLS for AirPlay compatibility");
+        await hlsPlugin.switchToNative();
+        video = null;
+        attachToVideo();
+      }
+      video?.webkitShowPlaybackTargetPicker?.();
+    },
+    isAvailable() {
+      return api?.getState("airplayAvailable") === true;
+    },
+    isActive() {
+      return api?.getState("airplayActive") === true;
+    },
+    stop() {
+      api?.logger.debug("AirPlay stop requested (use system controls to disconnect)");
+    }
+  };
+}
+var index_default = airplayPlugin;
+export {
+  airplayPlugin,
+  index_default as default,
+  isAirPlaySupported
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@scarlett-player/airplay",
+  "version": "0.1.0",
+  "description": "AirPlay 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",
+    "airplay",
+    "casting",
+    "scarlett"
+  ],
+  "author": "The Stream Platform",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Hackney-Enterprises-Inc/scarlett-player.git",
+    "directory": "packages/plugins/airplay"
+  },
+  "bugs": {
+    "url": "https://github.com/Hackney-Enterprises-Inc/scarlett-player/issues"
+  },
+  "homepage": "https://github.com/Hackney-Enterprises-Inc/scarlett-player#readme"
+}