@naxodev/opencode-music-player 0.2.5 → 0.3.0

package/tmux-offset.ts

@@ -1,120 +0,0 @@
-/**
- * Tmux pane-origin offset for absolute Kitty coordinates.
- *
- * Cache is keyed by OpenTUI **pre-offset** slot geometry so resize/layout
- * changes force a re-query even when wall-clock TTL would still allow a hit.
- */
-
-export type SlotGeometry = {
-  screenX: number
-  screenY: number
-  width: number
-  height: number
-}
-
-export type TmuxOffset = { x: number; y: number }
-
-export type TmuxOffsetQueryResult = {
-  ok: boolean
-  stdout: string
-}
-
-export type TmuxOffsetCache = {
-  offset: TmuxOffset | null
-  slot: SlotGeometry | null
-}
-
-const ZERO: TmuxOffset = { x: 0, y: 0 }
-
-export function createTmuxOffsetCache(): TmuxOffsetCache {
-  return { offset: null, slot: null }
-}
-
-/** True only when running under tmux without Herdr (Herdr already owns passthrough). */
-export function shouldUseTmuxOffset(
-  env: NodeJS.ProcessEnv = process.env,
-): boolean {
-  return Boolean(env.TMUX) && !env.HERDR_ENV
-}
-
-function slotKey(slot: SlotGeometry): string {
-  return [slot.screenX, slot.screenY, slot.width, slot.height].join(":")
-}
-
-function sameSlotGeometry(
-  a: SlotGeometry | null,
-  b: SlotGeometry | null,
-): boolean {
-  if (a === null || b === null) return false
-  return slotKey(a) === slotKey(b)
-}
-
-/**
- * Parse `tmux display-message -p '#{pane_left}\t#{pane_top}\t#{status-position}\t#{status}'`.
- * Status bar on top adds one row when status is not off.
- */
-export function parseTmuxOffsetMessage(stdout: string): TmuxOffset {
-  const [left, top, statusPosition, status] = stdout.trim().split("\t")
-  return {
-    x: Number.parseInt(left ?? "0", 10) || 0,
-    y:
-      (Number.parseInt(top ?? "0", 10) || 0) +
-      (statusPosition === "top" && status !== "off" ? 1 : 0),
-  }
-}
-
-function queryTmuxOffset(): TmuxOffsetQueryResult {
-  const result = Bun.spawnSync([
-    "tmux",
-    "display-message",
-    "-p",
-    "#{pane_left}\t#{pane_top}\t#{status-position}\t#{status}",
-  ])
-  return {
-    ok: result.exitCode === 0,
-    stdout: result.stdout.toString(),
-  }
-}
-
-/**
- * Resolve pane origin for absolute Kitty placement.
- *
- * - No TMUX / HERDR_ENV → zeros (no spawn).
- * - Slot geometry changed or first paint / empty cache → re-query.
- * - Identical slot + prior successful cache → reuse (no spawn).
- * - Failed query → zeros and clear cache so the next paint retries.
- */
-export function resolveTerminalOffset(options: {
-  env?: NodeJS.ProcessEnv
-  slot: SlotGeometry | null
-  cache: TmuxOffsetCache
-  query?: () => TmuxOffsetQueryResult
-}): TmuxOffset {
-  const env = options.env ?? process.env
-  if (!shouldUseTmuxOffset(env)) {
-    options.cache.offset = null
-    options.cache.slot = null
-    return ZERO
-  }
-
-  if (
-    options.cache.offset !== null &&
-    options.slot !== null &&
-    sameSlotGeometry(options.cache.slot, options.slot)
-  ) {
-    return options.cache.offset
-  }
-
-  const query = options.query ?? queryTmuxOffset
-  const result = query()
-  if (!result.ok) {
-    options.cache.offset = null
-    options.cache.slot = null
-    return ZERO
-  }
-
-  const offset = parseTmuxOffsetMessage(result.stdout)
-  options.cache.offset = offset
-  options.cache.slot = options.slot ? { ...options.slot } : null
-  return offset
-}

package/tui.tsx

@@ -1 +0,0 @@
-export { default } from "./index.tsx"

package/types.ts

@@ -1,143 +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>
-  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,
-    },
-  }
-}