@naxodev/opencode-music-player 0.2.6 → 0.3.1

package/types.ts

@@ -1,144 +0,0 @@
-import type {
-  PlayerState as CorePlayerState,
-  Track as CoreTrack,
-} from "@naxodev/music-core"
-import {
-  emptyPlayer as emptyCorePlayer,
-  formatMs,
-  isMac,
-} from "@naxodev/music-core"
-
-export type { Device, MusicError } from "@naxodev/music-core"
-export { formatMs, isMac }
-
-export type Artwork = {
-  id: string
-  legacy_id?: string
-  png_base64: string
-  accent: string
-  cells: Array<Array<{ upper: string; lower: string }>>
-}
-
-/** Native IDs validate artwork samples; recording metadata keys artwork work. */
-export type ArtworkIdentity = {
-  uid: string
-  title: string
-  artist: string
-  album: string
-  duration_ms: number
-}
-
-export type ArtworkCompletionEvent = {
-  type: "artwork-completion"
-  identity: ArtworkIdentity
-  artwork: Artwork | null
-  duration_ms: number
-}
-
-export type ArtworkPresentationListener = (
-  event: ArtworkCompletionEvent,
-) => void
-
-export type Track = CoreTrack & {
-  artwork: Artwork | null
-  artwork_loading?: boolean
-}
-
-export type PlayerState = Omit<CorePlayerState, "track"> & {
-  track: Track | null
-}
-
-export type SessionMediaSnapshotEvent = {
-  type: "snapshot"
-  state: PlayerState
-}
-
-/** Host-local projection of session provider/connection lifecycle. */
-export type SessionMediaLifecycleEvent = {
-  type: "lifecycle"
-  message: string | null
-  source: "connection" | "provider" | "acquisition"
-}
-
-export type SessionMediaEvent =
-  SessionMediaSnapshotEvent | SessionMediaLifecycleEvent
-export type SessionMediaListener = (event: SessionMediaEvent) => void
-export type SessionMediaDisposer = () => void
-
-/** The OpenCode controller's session-only media contract. */
-export type SessionMedia = {
-  player: () => Promise<PlayerState | null>
-  refreshArtwork: () => Promise<void>
-  play: () => Promise<unknown>
-  pause: () => Promise<unknown>
-  next: () => Promise<unknown>
-  previous: () => Promise<unknown>
-  seek: (positionMs: number) => Promise<unknown>
-  subscribe: (listener: SessionMediaListener) => SessionMediaDisposer
-  subscribePresentation: (
-    listener: ArtworkPresentationListener,
-  ) => SessionMediaDisposer
-  dispose: () => Promise<void>
-}
-
-export function emptyPlayer(): PlayerState {
-  return {
-    ...emptyCorePlayer(),
-    track: null,
-  }
-}
-
-/** Merge an independent artwork result without accepting stale playback data. */
-export function mergeArtworkCompletion(
-  player: PlayerState | null,
-  event: ArtworkCompletionEvent,
-): PlayerState | null {
-  const track = player?.track
-  if (
-    !track ||
-    track.name !== event.identity.title ||
-    track.artists !== event.identity.artist ||
-    track.album !== event.identity.album ||
-    (track.duration_ms > 0 && track.duration_ms !== event.identity.duration_ms)
-  ) {
-    return player
-  }
-  return {
-    ...player,
-    track: {
-      ...track,
-      artwork: event.artwork,
-      artwork_loading: false,
-    },
-  }
-}
-
-/** Keep host-local artwork presentation across playback-only snapshots. */
-export function mergePlayerSnapshot(
-  player: PlayerState | null,
-  snapshot: PlayerState,
-): PlayerState {
-  const current = player?.track
-  const next = snapshot.track
-  if (
-    !current ||
-    !next ||
-    current.name !== next.name ||
-    current.artists !== next.artists ||
-    current.album !== next.album ||
-    (current.duration_ms > 0 &&
-      next.duration_ms > 0 &&
-      current.duration_ms !== next.duration_ms) ||
-    (current.artwork === null && current.artwork_loading !== false)
-  ) {
-    return snapshot
-  }
-  return {
-    ...snapshot,
-    track: {
-      ...next,
-      artwork: next.artwork ?? current.artwork,
-      artwork_loading: false,
-    },
-  }
-}