@basmilius/apple-devices 0.9.11 → 0.9.12

package/dist/index.d.mts

@@ -5,11 +5,12 @@ import { EventEmitter } from "node:events";
 import { AccessoryCredentials, AudioSource, DiscoveryResult, TimingServer } from "@basmilius/apple-common";
 import { AttentionState, ButtonPressType, HidCommandKey, LaunchableApp, MediaControlCommandKey, Protocol as Protocol$1, UserAccount } from "@basmilius/apple-companion-link";
 
-//#region src/airplay/client.d.ts
-declare class Client {
+//#region src/airplay/player.d.ts
+declare class Player {
   #private;
-  get bundleIdentifier(): string;
+  get identifier(): string;
   get displayName(): string;
+  get isDefaultPlayer(): boolean;
   get nowPlayingInfo(): Proto.NowPlayingInfo | null;
   get playbackQueue(): Proto.PlaybackQueue | null;
   get playbackState(): Proto.PlaybackState_Enum;
@@ -35,7 +36,7 @@ declare class Client {
   get currentItemArtwork(): Uint8Array | null;
   get currentItemArtworkUrl(): string | null;
   get currentItemLyrics(): Proto.LyricsItem | null;
-  constructor(bundleIdentifier: string, displayName: string);
+  constructor(identifier: string, displayName: string);
   isCommandSupported(command: Proto.Command): boolean;
   setNowPlayingInfo(nowPlayingInfo: Proto.NowPlayingInfo): void;
   setPlaybackQueue(playbackQueue: Proto.PlaybackQueue): void;
@@ -44,6 +45,46 @@ declare class Client {
   updateContentItem(item: Proto.ContentItem): void;
 }
 //#endregion
+//#region src/airplay/client.d.ts
+declare class Client {
+  #private;
+  get bundleIdentifier(): string;
+  get displayName(): string;
+  get players(): Map<string, Player>;
+  get activePlayer(): Player | null;
+  get nowPlayingInfo(): Proto.NowPlayingInfo | null;
+  get playbackQueue(): Proto.PlaybackQueue | null;
+  get playbackState(): Proto.PlaybackState_Enum;
+  get playbackStateTimestamp(): number;
+  get supportedCommands(): Proto.CommandInfo[];
+  get title(): string;
+  get artist(): string;
+  get album(): string;
+  get genre(): string;
+  get seriesName(): string;
+  get seasonNumber(): number;
+  get episodeNumber(): number;
+  get mediaType(): Proto.ContentItemMetadata_MediaType;
+  get contentIdentifier(): string;
+  get duration(): number;
+  get playbackRate(): number;
+  get isPlaying(): boolean;
+  get shuffleMode(): Proto.ShuffleMode_Enum;
+  get repeatMode(): Proto.RepeatMode_Enum;
+  get elapsedTime(): number;
+  get currentItem(): Proto.ContentItem | null;
+  get currentItemMetadata(): Proto.ContentItemMetadata | null;
+  get currentItemArtwork(): Uint8Array | null;
+  get currentItemArtworkUrl(): string | null;
+  get currentItemLyrics(): Proto.LyricsItem | null;
+  constructor(bundleIdentifier: string, displayName: string);
+  getOrCreatePlayer(identifier: string, displayName?: string): Player;
+  setActivePlayer(identifier: string): void;
+  removePlayer(identifier: string): void;
+  setDefaultSupportedCommands(supportedCommands: Proto.CommandInfo[]): void;
+  isCommandSupported(command: Proto.Command): boolean;
+}
+//#endregion
 //#region src/airplay/const.d.ts
 declare const PROTOCOL: unique symbol;
 declare const STATE_SUBSCRIBE_SYMBOL: unique symbol;
@@ -102,6 +143,7 @@ type EventMap$4 = {
   readonly originClientProperties: [Proto.OriginClientPropertiesMessage];
   readonly playerClientProperties: [Proto.PlayerClientPropertiesMessage];
   readonly removeClient: [Proto.RemoveClientMessage];
+  readonly removePlayer: [Proto.RemovePlayerMessage];
   readonly sendCommandResult: [Proto.SendCommandResultMessage];
   readonly setArtwork: [Proto.SetArtworkMessage];
   readonly setDefaultSupportedCommands: [Proto.SetDefaultSupportedCommandsMessage];
@@ -144,6 +186,7 @@ declare class export_default$7 extends EventEmitter<EventMap$4> {
   onUpdateContentItem(message: Proto.UpdateContentItemMessage): void;
   onUpdateContentItemArtwork(message: Proto.UpdateContentItemArtworkMessage): void;
   onUpdatePlayer(message: Proto.UpdatePlayerMessage): void;
+  onRemovePlayer(message: Proto.RemovePlayerMessage): void;
   onUpdateClient(message: Proto.UpdateClientMessage): void;
   onUpdateOutputDevice(message: Proto.UpdateOutputDeviceMessage): void;
   onVolumeControlAvailability(message: Proto.VolumeControlAvailabilityMessage): void;

package/dist/index.mjs

@@ -4,21 +4,25 @@ import { EventEmitter } from "node:events";
 import { waitFor } from "@basmilius/apple-common";
 import { Protocol as Protocol$1, convertAttentionState } from "@basmilius/apple-companion-link";
 
-//#region src/airplay/client.ts
+//#region src/airplay/player.ts
 const COCOA_EPOCH_OFFSET = 978307200;
+const DEFAULT_PLAYER_ID = "MediaRemote-DefaultPlayer";
 const extrapolateElapsed = (elapsed, cocoaTimestamp, rate) => {
 	if (!rate) return elapsed;
 	const timestampUnix = cocoaTimestamp + COCOA_EPOCH_OFFSET;
 	const delta = (Date.now() / 1e3 - timestampUnix) * rate;
 	return Math.max(0, elapsed + delta);
 };
-var Client = class {
-	get bundleIdentifier() {
-		return this.#bundleIdentifier;
+var Player = class {
+	get identifier() {
+		return this.#identifier;
 	}
 	get displayName() {
 		return this.#displayName;
 	}
+	get isDefaultPlayer() {
+		return this.#identifier === DEFAULT_PLAYER_ID;
+	}
 	get nowPlayingInfo() {
 		return this.#nowPlayingInfo;
 	}
@@ -79,8 +83,14 @@ var Client = class {
 	get elapsedTime() {
 		const npi = this.#nowPlayingInfo;
 		const meta = this.currentItemMetadata;
-		if (npi?.elapsedTime != null && npi.timestamp) return extrapolateElapsed(npi.elapsedTime, npi.timestamp, npi.playbackRate);
-		if (meta?.elapsedTime != null && meta.elapsedTimeTimestamp) return extrapolateElapsed(meta.elapsedTime, meta.elapsedTimeTimestamp, meta.playbackRate);
+		const npiValid = npi?.elapsedTime != null && npi.timestamp;
+		const metaValid = meta?.elapsedTime != null && meta.elapsedTimeTimestamp;
+		if (npiValid && metaValid) {
+			if (meta.elapsedTimeTimestamp > npi.timestamp) return extrapolateElapsed(meta.elapsedTime, meta.elapsedTimeTimestamp, meta.playbackRate);
+			return extrapolateElapsed(npi.elapsedTime, npi.timestamp, npi.playbackRate);
+		}
+		if (npiValid) return extrapolateElapsed(npi.elapsedTime, npi.timestamp, npi.playbackRate);
+		if (metaValid) return extrapolateElapsed(meta.elapsedTime, meta.elapsedTimeTimestamp, meta.playbackRate);
 		return npi?.elapsedTime || meta?.elapsedTime || 0;
 	}
 	get currentItem() {
@@ -107,18 +117,17 @@ var Client = class {
 	get currentItemLyrics() {
 		return this.currentItem?.lyrics ?? null;
 	}
-	#bundleIdentifier;
+	#identifier;
 	#displayName;
 	#nowPlayingInfo = null;
 	#playbackQueue = null;
 	#playbackState;
-	#playbackStateTimestamp;
+	#playbackStateTimestamp = 0;
 	#supportedCommands = [];
-	constructor(bundleIdentifier, displayName) {
-		this.#bundleIdentifier = bundleIdentifier;
+	constructor(identifier, displayName) {
+		this.#identifier = identifier;
 		this.#displayName = displayName;
 		this.#playbackState = Proto.PlaybackState_Enum.Unknown;
-		this.#supportedCommands = [];
 	}
 	isCommandSupported(command) {
 		return this.#supportedCommands.some((c) => c.command === command);
@@ -150,6 +159,129 @@ var Client = class {
 	}
 };
 
+//#endregion
+//#region src/airplay/client.ts
+var Client = class {
+	get bundleIdentifier() {
+		return this.#bundleIdentifier;
+	}
+	get displayName() {
+		return this.#displayName;
+	}
+	get players() {
+		return this.#players;
+	}
+	get activePlayer() {
+		if (this.#activePlayerId) return this.#players.get(this.#activePlayerId) ?? null;
+		return this.#players.get(DEFAULT_PLAYER_ID) ?? null;
+	}
+	get nowPlayingInfo() {
+		return this.activePlayer?.nowPlayingInfo ?? null;
+	}
+	get playbackQueue() {
+		return this.activePlayer?.playbackQueue ?? null;
+	}
+	get playbackState() {
+		return this.activePlayer?.playbackState ?? Proto.PlaybackState_Enum.Unknown;
+	}
+	get playbackStateTimestamp() {
+		return this.activePlayer?.playbackStateTimestamp ?? -1;
+	}
+	get supportedCommands() {
+		return this.activePlayer?.supportedCommands ?? this.#defaultSupportedCommands;
+	}
+	get title() {
+		return this.activePlayer?.title ?? "";
+	}
+	get artist() {
+		return this.activePlayer?.artist ?? "";
+	}
+	get album() {
+		return this.activePlayer?.album ?? "";
+	}
+	get genre() {
+		return this.activePlayer?.genre ?? "";
+	}
+	get seriesName() {
+		return this.activePlayer?.seriesName ?? "";
+	}
+	get seasonNumber() {
+		return this.activePlayer?.seasonNumber ?? 0;
+	}
+	get episodeNumber() {
+		return this.activePlayer?.episodeNumber ?? 0;
+	}
+	get mediaType() {
+		return this.activePlayer?.mediaType ?? Proto.ContentItemMetadata_MediaType.UnknownMediaType;
+	}
+	get contentIdentifier() {
+		return this.activePlayer?.contentIdentifier ?? "";
+	}
+	get duration() {
+		return this.activePlayer?.duration ?? 0;
+	}
+	get playbackRate() {
+		return this.activePlayer?.playbackRate ?? 0;
+	}
+	get isPlaying() {
+		return this.activePlayer?.isPlaying ?? false;
+	}
+	get shuffleMode() {
+		return this.activePlayer?.shuffleMode ?? Proto.ShuffleMode_Enum.Unknown;
+	}
+	get repeatMode() {
+		return this.activePlayer?.repeatMode ?? Proto.RepeatMode_Enum.Unknown;
+	}
+	get elapsedTime() {
+		return this.activePlayer?.elapsedTime ?? 0;
+	}
+	get currentItem() {
+		return this.activePlayer?.currentItem ?? null;
+	}
+	get currentItemMetadata() {
+		return this.activePlayer?.currentItemMetadata ?? null;
+	}
+	get currentItemArtwork() {
+		return this.activePlayer?.currentItemArtwork ?? null;
+	}
+	get currentItemArtworkUrl() {
+		return this.activePlayer?.currentItemArtworkUrl ?? null;
+	}
+	get currentItemLyrics() {
+		return this.activePlayer?.currentItemLyrics ?? null;
+	}
+	#bundleIdentifier;
+	#displayName;
+	#players = /* @__PURE__ */ new Map();
+	#activePlayerId = null;
+	#defaultSupportedCommands = [];
+	constructor(bundleIdentifier, displayName) {
+		this.#bundleIdentifier = bundleIdentifier;
+		this.#displayName = displayName;
+	}
+	getOrCreatePlayer(identifier, displayName) {
+		let player = this.#players.get(identifier);
+		if (!player) {
+			player = new Player(identifier, displayName ?? identifier);
+			this.#players.set(identifier, player);
+		}
+		return player;
+	}
+	setActivePlayer(identifier) {
+		this.#activePlayerId = identifier;
+	}
+	removePlayer(identifier) {
+		this.#players.delete(identifier);
+		if (this.#activePlayerId === identifier) this.#activePlayerId = null;
+	}
+	setDefaultSupportedCommands(supportedCommands) {
+		this.#defaultSupportedCommands = supportedCommands;
+	}
+	isCommandSupported(command) {
+		return this.activePlayer?.isCommandSupported(command) ?? false;
+	}
+};
+
 //#endregion
 //#region src/airplay/const.ts
 const FEEDBACK_INTERVAL = 2e3;
@@ -364,6 +496,7 @@ var state_default = class extends EventEmitter {
 		this.onOriginClientProperties = this.onOriginClientProperties.bind(this);
 		this.onPlayerClientProperties = this.onPlayerClientProperties.bind(this);
 		this.onRemoveClient = this.onRemoveClient.bind(this);
+		this.onRemovePlayer = this.onRemovePlayer.bind(this);
 		this.onSendCommandResult = this.onSendCommandResult.bind(this);
 		this.onSetArtwork = this.onSetArtwork.bind(this);
 		this.onSetDefaultSupportedCommands = this.onSetDefaultSupportedCommands.bind(this);
@@ -385,6 +518,7 @@ var state_default = class extends EventEmitter {
 		this.#dataStream.on("originClientProperties", this.onOriginClientProperties);
 		this.#dataStream.on("playerClientProperties", this.onPlayerClientProperties);
 		this.#dataStream.on("removeClient", this.onRemoveClient);
+		this.#dataStream.on("removePlayer", this.onRemovePlayer);
 		this.#dataStream.on("sendCommandResult", this.onSendCommandResult);
 		this.#dataStream.on("setArtwork", this.onSetArtwork);
 		this.#dataStream.on("setDefaultSupportedCommands", this.onSetDefaultSupportedCommands);
@@ -408,6 +542,7 @@ var state_default = class extends EventEmitter {
 		dataStream.off("originClientProperties", this.onOriginClientProperties);
 		dataStream.off("playerClientProperties", this.onPlayerClientProperties);
 		dataStream.off("removeClient", this.onRemoveClient);
+		dataStream.off("removePlayer", this.onRemovePlayer);
 		dataStream.off("sendCommandResult", this.onSendCommandResult);
 		dataStream.off("setArtwork", this.onSetArtwork);
 		dataStream.off("setDefaultSupportedCommands", this.onSetDefaultSupportedCommands);
@@ -453,6 +588,8 @@ var state_default = class extends EventEmitter {
 	onRemoveClient(message) {
 		if (!(message.client.bundleIdentifier in this.#clients)) return;
 		delete this.#clients[message.client.bundleIdentifier];
+		if (this.#nowPlayingClientBundleIdentifier === message.client.bundleIdentifier) this.#nowPlayingClientBundleIdentifier = null;
+		this.emit("removeClient", message);
 		this.emit("clients", this.#clients);
 	}
 	onSendCommandResult(message) {
@@ -462,6 +599,7 @@ var state_default = class extends EventEmitter {
 		this.emit("setArtwork", message);
 	}
 	onSetDefaultSupportedCommands(message) {
+		if (message.playerPath?.client?.bundleIdentifier && message.supportedCommands) this.#client(message.playerPath.client.bundleIdentifier, message.playerPath.client.displayName).setDefaultSupportedCommands(message.supportedCommands.supportedCommands);
 		this.emit("setDefaultSupportedCommands", message);
 	}
 	onSetNowPlayingClient(message) {
@@ -469,28 +607,44 @@ var state_default = class extends EventEmitter {
 		this.emit("setNowPlayingClient", message);
 	}
 	onSetNowPlayingPlayer(message) {
+		if (message.playerPath?.client?.bundleIdentifier && message.playerPath?.player?.identifier) {
+			const client = this.#client(message.playerPath.client.bundleIdentifier, message.playerPath.client.displayName);
+			client.getOrCreatePlayer(message.playerPath.player.identifier, message.playerPath.player.displayName);
+			client.setActivePlayer(message.playerPath.player.identifier);
+		}
 		this.emit("setNowPlayingPlayer", message);
 	}
 	onSetState(message) {
 		const client = this.#client(message.playerPath.client.bundleIdentifier, message.displayName);
-		if (message.nowPlayingInfo) client.setNowPlayingInfo(message.nowPlayingInfo);
-		if (message.playbackState) client.setPlaybackState(message.playbackState, message.playbackStateTimestamp);
-		if (message.supportedCommands) client.setSupportedCommands(message.supportedCommands.supportedCommands);
-		if (message.playbackQueue) client.setPlaybackQueue(message.playbackQueue);
+		const playerIdentifier = message.playerPath?.player?.identifier || "MediaRemote-DefaultPlayer";
+		const player = client.getOrCreatePlayer(playerIdentifier, message.playerPath?.player?.displayName);
+		if (message.nowPlayingInfo) player.setNowPlayingInfo(message.nowPlayingInfo);
+		if (message.playbackState) player.setPlaybackState(message.playbackState, message.playbackStateTimestamp);
+		if (message.supportedCommands) player.setSupportedCommands(message.supportedCommands.supportedCommands);
+		if (message.playbackQueue) player.setPlaybackQueue(message.playbackQueue);
 		this.emit("setState", message);
 	}
 	onUpdateContentItem(message) {
 		const client = this.#client(message.playerPath.client.bundleIdentifier, message.playerPath.client.displayName);
-		if (!client) return;
-		for (const item of message.contentItems) client.updateContentItem(item);
+		const playerIdentifier = message.playerPath?.player?.identifier || "MediaRemote-DefaultPlayer";
+		const player = client.getOrCreatePlayer(playerIdentifier, message.playerPath?.player?.displayName);
+		for (const item of message.contentItems) player.updateContentItem(item);
 		this.emit("updateContentItem", message);
 	}
 	onUpdateContentItemArtwork(message) {
 		this.emit("updateContentItemArtwork", message);
 	}
 	onUpdatePlayer(message) {
+		if (message.playerPath?.client?.bundleIdentifier && message.playerPath?.player?.identifier) this.#client(message.playerPath.client.bundleIdentifier, message.playerPath.client.displayName).getOrCreatePlayer(message.playerPath.player.identifier, message.playerPath.player.displayName);
 		this.emit("updatePlayer", message);
 	}
+	onRemovePlayer(message) {
+		if (message.playerPath?.client?.bundleIdentifier && message.playerPath?.player?.identifier) {
+			const client = this.#clients[message.playerPath.client.bundleIdentifier];
+			if (client) client.removePlayer(message.playerPath.player.identifier);
+		}
+		this.emit("removePlayer", message);
+	}
 	onUpdateClient(message) {
 		this.#client(message.client.bundleIdentifier, message.client.displayName);
 		this.emit("clients", this.#clients);

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@basmilius/apple-devices",
     "description": "Exposes various Apple devices to connect with either AirPlay or Companion Link.",
-    "version": "0.9.11",
+    "version": "0.9.12",
     "type": "module",
     "license": "MIT",
     "author": {
@@ -49,10 +49,10 @@
         }
     },
     "dependencies": {
-        "@basmilius/apple-airplay": "0.9.11",
-        "@basmilius/apple-common": "0.9.11",
-        "@basmilius/apple-companion-link": "0.9.11",
-        "@basmilius/apple-encoding": "0.9.11"
+        "@basmilius/apple-airplay": "0.9.12",
+        "@basmilius/apple-common": "0.9.12",
+        "@basmilius/apple-companion-link": "0.9.12",
+        "@basmilius/apple-encoding": "0.9.12"
     },
     "devDependencies": {
         "@types/bun": "^1.3.9",