react-native-queue-player 1.0.0

package/lib/module/hooks/useCast.js

@@ -0,0 +1,107 @@
+"use strict";
+
+import { useEffect, useState } from 'react';
+import { addDiscoveryStateListener, addLocalNetworkPermissionListener, addReceiversListener, addRouteListener, addSessionDiedListener, getCurrentRoute, getReceivers, getSupportedProtocols, isCastAvailable, isDiscovering, localRoute } from "../cast/index.js";
+const INITIAL = {
+  supportedProtocols: [],
+  isAvailable: false,
+  receivers: [],
+  route: localRoute(),
+  isDiscovering: false,
+  lastSessionDied: null,
+  permission: 'undetermined'
+};
+
+/**
+ * Aggregated cast state for picker UIs. Subscribes to all five Cast
+ * event streams + reads the initial snapshot synchronously on mount.
+ *
+ * Returns a single object so consumers can pattern-match without
+ * threading five hook calls through their render. Consumers needing
+ * just one slice (e.g. only `receivers`) should still prefer this
+ * hook over the underlying listeners — the lib already debounces +
+ * coalesces updates.
+ */
+export function useCast() {
+  const [snapshot, setSnapshot] = useState(() => {
+    try {
+      const protocols = getSupportedProtocols();
+      return {
+        supportedProtocols: protocols,
+        isAvailable: protocols.length > 0,
+        receivers: getReceivers(),
+        route: getCurrentRoute(),
+        isDiscovering: isDiscovering(),
+        lastSessionDied: null,
+        permission: 'undetermined'
+      };
+    } catch {
+      return INITIAL;
+    }
+  });
+  useEffect(() => {
+    if (!isCastAvailable()) return;
+
+    // Each `addXxxListener` synchronously replays the current value on
+    // subscribe. The initial `useState` initializer already captured
+    // every initial value; skipping the first replay per stream avoids
+    // five back-to-back `setSnapshot` calls on mount.
+    let firstRoute = true;
+    let firstReceivers = true;
+    let firstDiscovery = true;
+    let firstPermission = true;
+    const routeSub = addRouteListener(route => {
+      if (firstRoute) {
+        firstRoute = false;
+        return;
+      }
+      setSnapshot(prev => ({
+        ...prev,
+        route
+      }));
+    });
+    const receiversSub = addReceiversListener(receivers => {
+      if (firstReceivers) {
+        firstReceivers = false;
+        return;
+      }
+      setSnapshot(prev => ({
+        ...prev,
+        receivers
+      }));
+    });
+    const discoverySub = addDiscoveryStateListener(state => {
+      if (firstDiscovery) {
+        firstDiscovery = false;
+        return;
+      }
+      setSnapshot(prev => ({
+        ...prev,
+        isDiscovering: state.isDiscovering
+      }));
+    });
+    const deathSub = addSessionDiedListener(event => setSnapshot(prev => ({
+      ...prev,
+      lastSessionDied: event
+    })));
+    const permissionSub = addLocalNetworkPermissionListener(event => {
+      if (firstPermission) {
+        firstPermission = false;
+        return;
+      }
+      setSnapshot(prev => ({
+        ...prev,
+        permission: event.state
+      }));
+    });
+    return () => {
+      routeSub.remove();
+      receiversSub.remove();
+      discoverySub.remove();
+      deathSub.remove();
+      permissionSub.remove();
+    };
+  }, []);
+  return snapshot;
+}
+//# sourceMappingURL=useCast.js.map

package/lib/module/hooks/useCast.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useEffect","useState","addDiscoveryStateListener","addLocalNetworkPermissionListener","addReceiversListener","addRouteListener","addSessionDiedListener","getCurrentRoute","getReceivers","getSupportedProtocols","isCastAvailable","isDiscovering","localRoute","INITIAL","supportedProtocols","isAvailable","receivers","route","lastSessionDied","permission","useCast","snapshot","setSnapshot","protocols","length","firstRoute","firstReceivers","firstDiscovery","firstPermission","routeSub","prev","receiversSub","discoverySub","state","deathSub","event","permissionSub","remove"],"sourceRoot":"../../../src","sources":["hooks/useCast.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/hooks/useEqualizer.js

@@ -0,0 +1,91 @@
+"use strict";
+
+import { useCallback, useEffect, useState } from 'react';
+import { getEqualizer } from "../clients.js";
+/**
+ * Subscribes to Equalizer band-change events and exposes imperative setters.
+ * Initial state is pulled synchronously on mount so consumers don't flash
+ * empty bands.
+ */
+export function useEqualizer() {
+  const [enabled, setEnabledState] = useState(() => {
+    try {
+      return getEqualizer().isEnabled();
+    } catch {
+      return false;
+    }
+  });
+  const [bands, setBands] = useState(() => {
+    try {
+      return getEqualizer().getBands();
+    } catch {
+      return [];
+    }
+  });
+  const [presets, setPresets] = useState(() => {
+    try {
+      return getEqualizer().getPresets();
+    } catch {
+      return [];
+    }
+  });
+  useEffect(() => {
+    const eq = getEqualizer();
+    const dispose = eq.onBandChange(updated => {
+      setBands(updated);
+    });
+    return dispose;
+  }, []);
+  const setEnabled = useCallback(async next => {
+    const eq = getEqualizer();
+    await eq.setEnabled(next);
+    // Read back rather than echoing the requested value: the native
+    // side may reject (or coerce) the change in a future build, and
+    // mirroring its actual state keeps JS aligned without a separate
+    // `onEnabledChange` event. Fall back to the requested value when
+    // the read-back throws (today's behaviour against the
+    // unimplemented native — matches the seed's try/catch on init).
+    try {
+      setEnabledState(eq.isEnabled());
+    } catch {
+      setEnabledState(next);
+    }
+  }, []);
+  const setBandGain = useCallback(async (index, gainDb) => {
+    await getEqualizer().setBandGain(index, gainDb);
+  }, []);
+  const setAllBandGains = useCallback(async gains => {
+    await getEqualizer().setAllBandGains(gains);
+  }, []);
+  const applyPreset = useCallback(async name => {
+    await getEqualizer().applyPreset(name);
+  }, []);
+
+  // TODO: wire onPresetsChange when added to Equalizer.nitro.ts —
+  // until then, save/delete refresh the local presets list with a
+  // manual sync re-fetch.
+  const saveCustomPreset = useCallback(async name => {
+    await getEqualizer().saveCustomPreset(name);
+    setPresets(getEqualizer().getPresets());
+  }, []);
+  const deleteCustomPreset = useCallback(async name => {
+    await getEqualizer().deleteCustomPreset(name);
+    setPresets(getEqualizer().getPresets());
+  }, []);
+  const reset = useCallback(async () => {
+    await getEqualizer().reset();
+  }, []);
+  return {
+    enabled,
+    bands,
+    presets,
+    setEnabled,
+    setBandGain,
+    setAllBandGains,
+    applyPreset,
+    saveCustomPreset,
+    deleteCustomPreset,
+    reset
+  };
+}
+//# sourceMappingURL=useEqualizer.js.map

package/lib/module/hooks/useEqualizer.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useCallback","useEffect","useState","getEqualizer","useEqualizer","enabled","setEnabledState","isEnabled","bands","setBands","getBands","presets","setPresets","getPresets","eq","dispose","onBandChange","updated","setEnabled","next","setBandGain","index","gainDb","setAllBandGains","gains","applyPreset","name","saveCustomPreset","deleteCustomPreset","reset"],"sourceRoot":"../../../src","sources":["hooks/useEqualizer.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/hooks/useFullyBuffered.js

@@ -0,0 +1,33 @@
+"use strict";
+
+import { useEffect, useState } from 'react';
+import { getTrackPlayer } from "../clients.js";
+
+/**
+ * Subscribes to native `onFullyBufferedChange` and returns whether the active
+ * track has fully downloaded (`true` once the whole media is buffered). Distinct
+ * from `useBufferState() === 'full'` (which is "enough buffered to keep up") —
+ * a track can keep up while still downloading. Use it to push a buffered bar to
+ * 100% or enable a full-length scrubber once nothing is left to transfer.
+ *
+ * ```tsx
+ * const fullyBuffered = useFullyBuffered();
+ * ```
+ *
+ * Always `false` for a live / unknown-length stream that never completes.
+ */
+export function useFullyBuffered() {
+  const [fullyBuffered, setFullyBuffered] = useState(() => {
+    try {
+      return getTrackPlayer().isFullyBuffered();
+    } catch {
+      return false;
+    }
+  });
+  useEffect(() => {
+    const player = getTrackPlayer();
+    return player.onFullyBufferedChange(setFullyBuffered);
+  }, []);
+  return fullyBuffered;
+}
+//# sourceMappingURL=useFullyBuffered.js.map

package/lib/module/hooks/useFullyBuffered.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useEffect","useState","getTrackPlayer","useFullyBuffered","fullyBuffered","setFullyBuffered","isFullyBuffered","player","onFullyBufferedChange"],"sourceRoot":"../../../src","sources":["hooks/useFullyBuffered.ts"],"mappings":";;AAAA,SAASA,SAAS,EAAEC,QAAQ,QAAQ,OAAO;AAC3C,SAASC,cAAc,QAAQ,eAAY;;AAE3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,gBAAgBA,CAAA,EAAY;EAC1C,MAAM,CAACC,aAAa,EAAEC,gBAAgB,CAAC,GAAGJ,QAAQ,CAAU,MAAM;IAChE,IAAI;MACF,OAAOC,cAAc,CAAC,CAAC,CAACI,eAAe,CAAC,CAAC;IAC3C,CAAC,CAAC,MAAM;MACN,OAAO,KAAK;IACd;EACF,CAAC,CAAC;EAEFN,SAAS,CAAC,MAAM;IACd,MAAMO,MAAM,GAAGL,cAAc,CAAC,CAAC;IAC/B,OAAOK,MAAM,CAACC,qBAAqB,CAACH,gBAAgB,CAAC;EACvD,CAAC,EAAE,EAAE,CAAC;EAEN,OAAOD,aAAa;AACtB","ignoreList":[]}

package/lib/module/hooks/useLookaheadCache.js

@@ -0,0 +1,49 @@
+"use strict";
+
+import { useCallback, useEffect, useState } from 'react';
+import { getTrackPlayer } from "../clients.js";
+// Pre-install fallback. `maxSizeMb: 100` matches the lib's documented
+// default so consumers reading the value before the first
+// `onCacheStatusChange` event don't see a misleading "0 MB budget".
+// The first event overrides this with the actual configured value.
+const INITIAL = {
+  enabled: false,
+  currentSizeMb: 0,
+  maxSizeMb: 100,
+  tracksFullyCached: 0,
+  currentlyCaching: []
+};
+
+/**
+ * Subscribes to lookahead-cache status updates and exposes imperative
+ * setters for runtime reconfiguration (e.g. switch from wifi → cellular
+ * and drop the lookahead count).
+ */
+export function useLookaheadCache() {
+  const [status, setStatus] = useState(() => {
+    try {
+      return getTrackPlayer().getLookaheadCacheStatus();
+    } catch {
+      return INITIAL;
+    }
+  });
+  useEffect(() => {
+    const player = getTrackPlayer();
+    const dispose = player.onCacheStatusChange(next => {
+      setStatus(next);
+    });
+    return dispose;
+  }, []);
+  const setConfig = useCallback(async config => {
+    await getTrackPlayer().setLookaheadCache(config);
+  }, []);
+  const clear = useCallback(async () => {
+    await getTrackPlayer().clearLookaheadCache();
+  }, []);
+  return {
+    status,
+    setConfig,
+    clear
+  };
+}
+//# sourceMappingURL=useLookaheadCache.js.map

package/lib/module/hooks/useLookaheadCache.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useCallback","useEffect","useState","getTrackPlayer","INITIAL","enabled","currentSizeMb","maxSizeMb","tracksFullyCached","currentlyCaching","useLookaheadCache","status","setStatus","getLookaheadCacheStatus","player","dispose","onCacheStatusChange","next","setConfig","config","setLookaheadCache","clear","clearLookaheadCache"],"sourceRoot":"../../../src","sources":["hooks/useLookaheadCache.ts"],"mappings":";;AAAA,SAASA,WAAW,EAAEC,SAAS,EAAEC,QAAQ,QAAQ,OAAO;AACxD,SAASC,cAAc,QAAQ,eAAY;AAS3C;AACA;AACA;AACA;AACA,MAAMC,OAAoB,GAAG;EAC3BC,OAAO,EAAE,KAAK;EACdC,aAAa,EAAE,CAAC;EAChBC,SAAS,EAAE,GAAG;EACdC,iBAAiB,EAAE,CAAC;EACpBC,gBAAgB,EAAE;AACpB,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,iBAAiBA,CAAA,EAA4B;EAC3D,MAAM,CAACC,MAAM,EAAEC,SAAS,CAAC,GAAGV,QAAQ,CAAc,MAAM;IACtD,IAAI;MACF,OAAOC,cAAc,CAAC,CAAC,CAACU,uBAAuB,CAAC,CAAC;IACnD,CAAC,CAAC,MAAM;MACN,OAAOT,OAAO;IAChB;EACF,CAAC,CAAC;EAEFH,SAAS,CAAC,MAAM;IACd,MAAMa,MAAM,GAAGX,cAAc,CAAC,CAAC;IAC/B,MAAMY,OAAO,GAAGD,MAAM,CAACE,mBAAmB,CAAEC,IAAI,IAAK;MACnDL,SAAS,CAACK,IAAI,CAAC;IACjB,CAAC,CAAC;IACF,OAAOF,OAAO;EAChB,CAAC,EAAE,EAAE,CAAC;EAEN,MAAMG,SAAS,GAAGlB,WAAW,CAAC,MAAOmB,MAA4B,IAAK;IACpE,MAAMhB,cAAc,CAAC,CAAC,CAACiB,iBAAiB,CAACD,MAAM,CAAC;EAClD,CAAC,EAAE,EAAE,CAAC;EAEN,MAAME,KAAK,GAAGrB,WAAW,CAAC,YAAY;IACpC,MAAMG,cAAc,CAAC,CAAC,CAACmB,mBAAmB,CAAC,CAAC;EAC9C,CAAC,EAAE,EAAE,CAAC;EAEN,OAAO;IAAEX,MAAM;IAAEO,SAAS;IAAEG;EAAM,CAAC;AACrC","ignoreList":[]}

package/lib/module/hooks/useNowPlayingFormat.js

@@ -0,0 +1,42 @@
+"use strict";
+
+import { useEffect, useState } from 'react';
+import { getTrackPlayer } from "../clients.js";
+/**
+ * Subscribes to native `onNowPlayingFormatChange` updates.
+ *
+ * Returns `null` until the native side has resolved the active
+ * track's audio format. iOS requires `await asset.load(.tracks,
+ * .formatDescriptions, .estimatedDataRate)` per item; Android lands
+ * the data via `Player.Listener.onTracksChanged(Tracks)` before
+ * STATE_READY. Either way the format arrives moments after the
+ * `onTrackChange` event for that item — render against `null`
+ * during the gap.
+ *
+ * The first-render seed reads `getNowPlayingFormat()` synchronously
+ * so a tab re-mount mid-playback doesn't transiently flash `null`
+ * if the format is already known.
+ */
+export function useNowPlayingFormat() {
+  const [format, setFormat] = useState(() => {
+    try {
+      return getTrackPlayer().getNowPlayingFormat();
+    } catch {
+      return null;
+    }
+  });
+  useEffect(() => {
+    const player = getTrackPlayer();
+    // Nitrogen types this callback parameter as `NowPlayingFormat | null
+    // | undefined` (the variant is generated as nullable-optional). Both
+    // native implementations always emit the explicit-null variant, but
+    // normalising `undefined → null` keeps the hook's React state strict
+    // against the documented `NowPlayingFormat | null` contract.
+    const dispose = player.onNowPlayingFormatChange(next => {
+      setFormat(next ?? null);
+    });
+    return dispose;
+  }, []);
+  return format;
+}
+//# sourceMappingURL=useNowPlayingFormat.js.map

package/lib/module/hooks/useNowPlayingFormat.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useEffect","useState","getTrackPlayer","useNowPlayingFormat","format","setFormat","getNowPlayingFormat","player","dispose","onNowPlayingFormatChange","next"],"sourceRoot":"../../../src","sources":["hooks/useNowPlayingFormat.ts"],"mappings":";;AAAA,SAASA,SAAS,EAAEC,QAAQ,QAAQ,OAAO;AAC3C,SAASC,cAAc,QAAQ,eAAY;AAG3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,mBAAmBA,CAAA,EAA4B;EAC7D,MAAM,CAACC,MAAM,EAAEC,SAAS,CAAC,GAAGJ,QAAQ,CAA0B,MAAM;IAClE,IAAI;MACF,OAAOC,cAAc,CAAC,CAAC,CAACI,mBAAmB,CAAC,CAAC;IAC/C,CAAC,CAAC,MAAM;MACN,OAAO,IAAI;IACb;EACF,CAAC,CAAC;EAEFN,SAAS,CAAC,MAAM;IACd,MAAMO,MAAM,GAAGL,cAAc,CAAC,CAAC;IAC/B;IACA;IACA;IACA;IACA;IACA,MAAMM,OAAO,GAAGD,MAAM,CAACE,wBAAwB,CAAEC,IAAI,IAAK;MACxDL,SAAS,CAACK,IAAI,IAAI,IAAI,CAAC;IACzB,CAAC,CAAC;IACF,OAAOF,OAAO;EAChB,CAAC,EAAE,EAAE,CAAC;EAEN,OAAOJ,MAAM;AACf","ignoreList":[]}

package/lib/module/hooks/usePlaybackState.js

@@ -0,0 +1,36 @@
+"use strict";
+
+import { useEffect, useState } from 'react';
+import { getTrackPlayer } from "../clients.js";
+const INITIAL = {
+  state: 'none',
+  reason: 'system'
+};
+
+/** Subscribes to native `onStateChange` updates. */
+export function usePlaybackState() {
+  const [snapshot, setSnapshot] = useState(() => {
+    // Pull the current state synchronously on first render so consumers
+    // don't flash 'none' on mount.
+    try {
+      return {
+        state: getTrackPlayer().getState(),
+        reason: 'system'
+      };
+    } catch {
+      return INITIAL;
+    }
+  });
+  useEffect(() => {
+    const player = getTrackPlayer();
+    const dispose = player.onStateChange((state, reason) => {
+      setSnapshot({
+        state,
+        reason
+      });
+    });
+    return dispose;
+  }, []);
+  return snapshot;
+}
+//# sourceMappingURL=usePlaybackState.js.map

package/lib/module/hooks/usePlaybackState.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useEffect","useState","getTrackPlayer","INITIAL","state","reason","usePlaybackState","snapshot","setSnapshot","getState","player","dispose","onStateChange"],"sourceRoot":"../../../src","sources":["hooks/usePlaybackState.ts"],"mappings":";;AAAA,SAASA,SAAS,EAAEC,QAAQ,QAAQ,OAAO;AAC3C,SAASC,cAAc,QAAQ,eAAY;AAS3C,MAAMC,OAA8B,GAAG;EAAEC,KAAK,EAAE,MAAM;EAAEC,MAAM,EAAE;AAAS,CAAC;;AAE1E;AACA,OAAO,SAASC,gBAAgBA,CAAA,EAA0B;EACxD,MAAM,CAACC,QAAQ,EAAEC,WAAW,CAAC,GAAGP,QAAQ,CAAwB,MAAM;IACpE;IACA;IACA,IAAI;MACF,OAAO;QAAEG,KAAK,EAAEF,cAAc,CAAC,CAAC,CAACO,QAAQ,CAAC,CAAC;QAAEJ,MAAM,EAAE;MAAS,CAAC;IACjE,CAAC,CAAC,MAAM;MACN,OAAOF,OAAO;IAChB;EACF,CAAC,CAAC;EAEFH,SAAS,CAAC,MAAM;IACd,MAAMU,MAAM,GAAGR,cAAc,CAAC,CAAC;IAC/B,MAAMS,OAAO,GAAGD,MAAM,CAACE,aAAa,CAAC,CAACR,KAAK,EAAEC,MAAM,KAAK;MACtDG,WAAW,CAAC;QAAEJ,KAAK;QAAEC;MAAO,CAAC,CAAC;IAChC,CAAC,CAAC;IACF,OAAOM,OAAO;EAChB,CAAC,EAAE,EAAE,CAAC;EAEN,OAAOJ,QAAQ;AACjB","ignoreList":[]}

package/lib/module/hooks/useProgress.js

@@ -0,0 +1,31 @@
+"use strict";
+
+import { useEffect, useState } from 'react';
+import { getTrackPlayer } from "../clients.js";
+const INITIAL = {
+  position: 0,
+  duration: 0,
+  buffered: 0
+};
+
+/**
+ * Subscribes to native `onProgress` updates. Progress is driven by a native
+ * periodic timer (see NOTES.md §5), so this hook stays accurate even when
+ * the app is backgrounded.
+ */
+export function useProgress() {
+  const [progress, setProgress] = useState(INITIAL);
+  useEffect(() => {
+    const player = getTrackPlayer();
+    const dispose = player.onProgress(p => {
+      setProgress({
+        position: p.position,
+        duration: p.duration,
+        buffered: p.buffered
+      });
+    });
+    return dispose;
+  }, []);
+  return progress;
+}
+//# sourceMappingURL=useProgress.js.map

package/lib/module/hooks/useProgress.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useEffect","useState","getTrackPlayer","INITIAL","position","duration","buffered","useProgress","progress","setProgress","player","dispose","onProgress","p"],"sourceRoot":"../../../src","sources":["hooks/useProgress.ts"],"mappings":";;AAAA,SAASA,SAAS,EAAEC,QAAQ,QAAQ,OAAO;AAC3C,SAASC,cAAc,QAAQ,eAAY;AAW3C,MAAMC,OAAsB,GAAG;EAAEC,QAAQ,EAAE,CAAC;EAAEC,QAAQ,EAAE,CAAC;EAAEC,QAAQ,EAAE;AAAE,CAAC;;AAExE;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,WAAWA,CAAA,EAAkB;EAC3C,MAAM,CAACC,QAAQ,EAAEC,WAAW,CAAC,GAAGR,QAAQ,CAAgBE,OAAO,CAAC;EAEhEH,SAAS,CAAC,MAAM;IACd,MAAMU,MAAM,GAAGR,cAAc,CAAC,CAAC;IAC/B,MAAMS,OAAO,GAAGD,MAAM,CAACE,UAAU,CAAEC,CAAC,IAAK;MACvCJ,WAAW,CAAC;QACVL,QAAQ,EAAES,CAAC,CAACT,QAAQ;QACpBC,QAAQ,EAAEQ,CAAC,CAACR,QAAQ;QACpBC,QAAQ,EAAEO,CAAC,CAACP;MACd,CAAC,CAAC;IACJ,CAAC,CAAC;IACF,OAAOK,OAAO;EAChB,CAAC,EAAE,EAAE,CAAC;EAEN,OAAOH,QAAQ;AACjB","ignoreList":[]}

package/lib/module/hooks/useSleepTimer.js

@@ -0,0 +1,65 @@
+"use strict";
+
+import { useEffect, useState } from 'react';
+import { getTrackPlayer } from "../clients.js";
+const INACTIVE = {
+  active: false,
+  endOfTrack: false
+};
+
+/** Whole seconds until the wall-clock deadline, or undefined when there isn't one yet. */
+function remainingFrom(state) {
+  if (state.endsAtEpochMs === undefined) return undefined;
+  return Math.max(0, Math.round((state.endsAtEpochMs - Date.now()) / 1000));
+}
+
+/**
+ * Subscribes to native `onSleepTimerChange` and exposes the current sleep-timer
+ * state. `remainingSeconds` is recomputed locally once a second from the
+ * wall-clock `endsAtEpochMs`, so a countdown label stays live — the native side
+ * emits only on arm / clear / end-of-track conversion / fire, not on every tick.
+ *
+ * ```tsx
+ * const timer = useSleepTimer();
+ * // arm: player.setSleepTimer(15 * 60) or player.setSleepTimerToTrackEnd()
+ * {timer.active && (
+ *   <Text>
+ *     {timer.remainingSeconds === undefined
+ *       ? 'Stopping at end of track'
+ *       : `Sleeping in ${timer.remainingSeconds}s`}
+ *   </Text>
+ * )}
+ * ```
+ *
+ * When end-of-track is armed, `endsAtEpochMs` / `remainingSeconds` are absent
+ * while `endOfTrack` is true. Once the current track enters the tail window the
+ * timer converts to a concrete countdown: `endOfTrack` flips to false and
+ * `remainingSeconds` starts counting down.
+ */
+export function useSleepTimer() {
+  const [state, setState] = useState(() => {
+    try {
+      return getTrackPlayer().getSleepTimer();
+    } catch {
+      return INACTIVE;
+    }
+  });
+  useEffect(() => {
+    const player = getTrackPlayer();
+    return player.onSleepTimerChange(setState);
+  }, []);
+  const [remainingSeconds, setRemainingSeconds] = useState(() => remainingFrom(state));
+  useEffect(() => {
+    setRemainingSeconds(remainingFrom(state));
+    // Only a concrete duration has a deadline to count down; inactive and
+    // awaiting-end-of-track states carry no `endsAtEpochMs`, so no interval runs.
+    if (state.endsAtEpochMs === undefined) return;
+    const id = setInterval(() => setRemainingSeconds(remainingFrom(state)), 1000);
+    return () => clearInterval(id);
+  }, [state]);
+  return {
+    ...state,
+    remainingSeconds
+  };
+}
+//# sourceMappingURL=useSleepTimer.js.map

package/lib/module/hooks/useSleepTimer.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useEffect","useState","getTrackPlayer","INACTIVE","active","endOfTrack","remainingFrom","state","endsAtEpochMs","undefined","Math","max","round","Date","now","useSleepTimer","setState","getSleepTimer","player","onSleepTimerChange","remainingSeconds","setRemainingSeconds","id","setInterval","clearInterval"],"sourceRoot":"../../../src","sources":["hooks/useSleepTimer.ts"],"mappings":";;AAAA,SAASA,SAAS,EAAEC,QAAQ,QAAQ,OAAO;AAC3C,SAASC,cAAc,QAAQ,eAAY;AAG3C,MAAMC,QAAyB,GAAG;EAAEC,MAAM,EAAE,KAAK;EAAEC,UAAU,EAAE;AAAM,CAAC;;AAEtE;AACA,SAASC,aAAaA,CAACC,KAAsB,EAAsB;EACjE,IAAIA,KAAK,CAACC,aAAa,KAAKC,SAAS,EAAE,OAAOA,SAAS;EACvD,OAAOC,IAAI,CAACC,GAAG,CAAC,CAAC,EAAED,IAAI,CAACE,KAAK,CAAC,CAACL,KAAK,CAACC,aAAa,GAAGK,IAAI,CAACC,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC;AAC3E;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,aAAaA,CAAA,EAAoB;EAC/C,MAAM,CAACR,KAAK,EAAES,QAAQ,CAAC,GAAGf,QAAQ,CAAkB,MAAM;IACxD,IAAI;MACF,OAAOC,cAAc,CAAC,CAAC,CAACe,aAAa,CAAC,CAAC;IACzC,CAAC,CAAC,MAAM;MACN,OAAOd,QAAQ;IACjB;EACF,CAAC,CAAC;EAEFH,SAAS,CAAC,MAAM;IACd,MAAMkB,MAAM,GAAGhB,cAAc,CAAC,CAAC;IAC/B,OAAOgB,MAAM,CAACC,kBAAkB,CAACH,QAAQ,CAAC;EAC5C,CAAC,EAAE,EAAE,CAAC;EAEN,MAAM,CAACI,gBAAgB,EAAEC,mBAAmB,CAAC,GAAGpB,QAAQ,CACtD,MAAMK,aAAa,CAACC,KAAK,CAC3B,CAAC;EACDP,SAAS,CAAC,MAAM;IACdqB,mBAAmB,CAACf,aAAa,CAACC,KAAK,CAAC,CAAC;IACzC;IACA;IACA,IAAIA,KAAK,CAACC,aAAa,KAAKC,SAAS,EAAE;IACvC,MAAMa,EAAE,GAAGC,WAAW,CAAC,MAAMF,mBAAmB,CAACf,aAAa,CAACC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC;IAC7E,OAAO,MAAMiB,aAAa,CAACF,EAAE,CAAC;EAChC,CAAC,EAAE,CAACf,KAAK,CAAC,CAAC;EAEX,OAAO;IAAE,GAAGA,KAAK;IAAEa;EAAiB,CAAC;AACvC","ignoreList":[]}

package/lib/module/hooks/useVisualizerState.js

@@ -0,0 +1,99 @@
+"use strict";
+
+import { useEffect, useRef, useState } from 'react';
+import { getVisualizer } from "../clients.js";
+const INITIAL = {
+  fft: null,
+  samples: null,
+  sampleRate: 0,
+  available: false,
+  reason: null
+};
+
+/**
+ * Subscribe to the Visualizer for the lifetime of the hook + surface
+ * the latest frame as plain React state at `sampleRateHz` cadence
+ * (default 30 Hz).
+ *
+ * The native bridge fires frames at `config.updateIntervalMs` (the
+ * audio render thread cadence — typically 60+ Hz). Throttling to
+ * 30 Hz on the React side keeps re-render pressure manageable; ~25
+ * FPS is enough for the visualizer aesthetic and renders smoothly
+ * on 60 Hz screens.
+ *
+ * The subscription re-creates only on primitive `config` field
+ * changes — passing an inline literal each render is safe.
+ *
+ * Effects cleanly: when the hook unmounts, the disposer runs; when
+ * no other subscribers are live, the native layer pauses FFT
+ * processing.
+ */
+export function useVisualizerState(config, sampleRateHz = 30) {
+  const [state, setState] = useState(INITIAL);
+  // Pull primitive config fields into local scope so the effect dep
+  // array can list them directly — passing an inline `config` object
+  // each render would re-fire the effect on every parent re-render.
+  const {
+    fftSize,
+    updateIntervalMs,
+    includeSamples
+  } = config;
+
+  // Latest frame held in a ref so the audio-thread bridge callback
+  // doesn't trigger a React re-render per frame. The throttle
+  // interval below pulls from the ref. `frameEpochRef` increments
+  // once per native frame so the throttle can detect "no new frame
+  // since last setState" and skip the re-render entirely.
+  const latestFrameRef = useRef(null);
+  const latestReasonRef = useRef(null);
+  const frameEpochRef = useRef(0);
+  useEffect(() => {
+    const viz = getVisualizer();
+    const dispose = viz.subscribe({
+      fftSize,
+      updateIntervalMs,
+      includeSamples
+    }, frame => {
+      latestFrameRef.current = frame;
+      latestReasonRef.current = null;
+      frameEpochRef.current += 1;
+    }, reason => {
+      latestReasonRef.current = reason;
+    });
+    const intervalMs = Math.max(16, Math.round(1000 / sampleRateHz));
+    let lastSeenEpoch = 0;
+    let lastSeenReason = null;
+    const timer = setInterval(() => {
+      const frame = latestFrameRef.current;
+      const reason = latestReasonRef.current;
+      const epoch = frameEpochRef.current;
+      if (frame && epoch !== lastSeenEpoch) {
+        lastSeenEpoch = epoch;
+        lastSeenReason = reason;
+        setState({
+          fft: new Float32Array(frame.fft),
+          samples: frame.samples ? new Float32Array(frame.samples) : null,
+          sampleRate: frame.sampleRate,
+          available: reason === null,
+          reason
+        });
+      } else if (reason && reason !== lastSeenReason) {
+        lastSeenReason = reason;
+        setState(prev => ({
+          ...prev,
+          reason,
+          available: false
+        }));
+      }
+    }, intervalMs);
+    return () => {
+      clearInterval(timer);
+      dispose();
+      latestFrameRef.current = null;
+      latestReasonRef.current = null;
+      frameEpochRef.current = 0;
+    };
+  }, [fftSize, updateIntervalMs, includeSamples, sampleRateHz]);
+  return state;
+}
+//# sourceMappingURL=useVisualizerState.js.map

package/lib/module/hooks/useVisualizerState.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useEffect","useRef","useState","getVisualizer","INITIAL","fft","samples","sampleRate","available","reason","useVisualizerState","config","sampleRateHz","state","setState","fftSize","updateIntervalMs","includeSamples","latestFrameRef","latestReasonRef","frameEpochRef","viz","dispose","subscribe","frame","current","intervalMs","Math","max","round","lastSeenEpoch","lastSeenReason","timer","setInterval","epoch","Float32Array","prev","clearInterval"],"sourceRoot":"../../../src","sources":["hooks/useVisualizerState.ts"],"mappings":"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","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,37 @@
+"use strict";
+
+// HybridObject type exports
+
+// All value types live in src/types.ts — see there for the canonical home.
+
+// HybridObject accessors — defined in `clients.ts` to break the
+// require cycle between `index.ts` and `hooks/*` (each hook needs
+// `getTrackPlayer` etc, but `index.ts` re-exports the hooks).
+export { getCastManager, getEqualizer, getTrackPlayer, getVisualizer } from "./clients.js";
+
+// Automotive / voice — playback service registration. Consumer registers
+// a handler factory once at app boot to service browse / search / play
+// requests routed in from CarPlay, Android Auto, and voice assistants.
+export { registerPlaybackService, unregisterPlaybackService } from "./playbackService.js";
+// Canonical bounds for `crossfadeDurationMs`; consumer apps building
+// stepper / slider UIs read from here.
+export { crossfadeDurationBounds } from "./types.js";
+
+// Automotive — closed enum of tab-bar icons the lib knows how to
+// render. Consumers reference `SectionIcon.Albums` etc; lib maps to
+// SF Symbol on iOS. Android Auto has no tab-icon API today.
+export { SectionIcon } from "./types.js";
+
+// Pure-function equalizer helpers — range constants, band frequency
+// table, clamp + lookup utilities. Live alongside the imperative
+// `getEqualizer()` API for consumers building EQ UIs.
+export { EQ_BAND_COUNT, EQ_BAND_FREQUENCIES_HZ, EQ_FLAT_PRESET_NAME, EQ_GAIN_MAX_DB, EQ_GAIN_MIN_DB, clampGain, gainsFromBands, gainsFromMap, isBuiltinPreset, nearestBandIndex } from "./equalizer.js";
+
+// React hooks — thin observers over the HybridObject event surface.
+export * from "./hooks/index.js";
+
+// Cast — Promise-based wrappers + listener subscriptions around the
+// `CastManager` HybridObject. Consumers can either reach in via
+// `getCastManager()` directly or import from `react-native-queue-player/cast`.
+export * as Cast from "./cast/index.js";
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getCastManager","getEqualizer","getTrackPlayer","getVisualizer","registerPlaybackService","unregisterPlaybackService","crossfadeDurationBounds","SectionIcon","EQ_BAND_COUNT","EQ_BAND_FREQUENCIES_HZ","EQ_FLAT_PRESET_NAME","EQ_GAIN_MAX_DB","EQ_GAIN_MIN_DB","clampGain","gainsFromBands","gainsFromMap","isBuiltinPreset","nearestBandIndex","Cast"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;AAAA;;AAMA;;AAsEA;AACA;AACA;AACA,SAASA,cAAc,EAAEC,YAAY,EAAEC,cAAc,EAAEC,aAAa,QAAQ,cAAW;;AAEvF;AACA;AACA;AACA,SACEC,uBAAuB,EACvBC,yBAAyB,QACpB,sBAAmB;AAM1B;AACA;AACA,SAASC,uBAAuB,QAAQ,YAAS;;AAEjD;AACA;AACA;AACA,SAASC,WAAW,QAAQ,YAAS;;AAErC;AACA;AACA;AACA,SACEC,aAAa,EACbC,sBAAsB,EACtBC,mBAAmB,EACnBC,cAAc,EACdC,cAAc,EACdC,SAAS,EACTC,cAAc,EACdC,YAAY,EACZC,eAAe,EACfC,gBAAgB,QACX,gBAAa;;AAEpB;AACA,cAAc,kBAAS;;AAEvB;AACA;AACA;AACA,OAAO,KAAKC,IAAI,MAAM,iBAAQ","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}