react-native-audio-browser 0.2.0-next.8 → 0.2.0

package/lib/module/features/gate.js

@@ -1,144 +0,0 @@
-"use strict";
-
-import { nativeBrowser } from '../native';
-import { LazyNativeEmitter } from '../utils/LazyNativeEmitter';
-
-// MARK: - Wire types (cross the Nitro bridge; native↔JS)
-
-/** Discriminant for gate requests and events. */
-
-/**
- * Flat wire struct for a gate request (crosses the Nitro bridge).
- * Use {@link GateRequest} in consumer-facing code; `gate.ts` converts between them.
- * @internal
- */
-
-/**
- * Wire form of a resolver result (native awaits this from JS).
- * @internal
- */
-
-/**
- * Fired once per gated serve (each time the gate chrome is rendered for a
- * request). This is **not** once per user action: on car surfaces a single
- * action can serve the gate for several requests at once — e.g. building the
- * tab bar resolves and serves each gated tab, firing one event per gated tab.
- * There is no library-side dedup; debounce on the consumer side (e.g. record a
- * gate-hit at most once per session).
- */
-
-// MARK: - Public types (consumer-facing)
-
-/**
- * A gate's chrome (title and optional message).
- *
- * While the gate is active, every browse or search request on car surfaces
- * (CarPlay, Android Auto) shows this page instead of the real content.
- * Playback, the queue, and now-playing are unaffected.
- *
- * - **CarPlay**: plain centered message page.
- * - **Android Auto**: one non-playable list tile (message not shown).
- */
-
-/**
- * The gate chrome crosses the bridge as-is; this alias marks the wire side.
- * @internal
- */
-
-/**
- * Describes the request being decided by a {@link GateResolver}.
- * Discriminated by `kind`: `'browse'` for content navigation, `'search'` for
- * voice/manual search queries.
- */
-
-/**
- * Decides per request whether to gate.
- * - Return a {@link Gate} to gate with specific chrome for this request.
- * - Return `true` to gate using the default chrome (or the built-in fallback).
- * - Return `false` to allow the request through.
- */
-
-// MARK: - Internal state
-
-let resolver;
-function toPublicRequest(req) {
-  switch (req.reason) {
-    case 'browse':
-      return {
-        kind: 'browse',
-        path: req.path ?? ''
-      };
-    case 'search':
-      // req.search is always present on a well-formed search request — the
-      // native wire contract guarantees it for reason:'search'. Assert the
-      // native contract with `!` so we never hand consumer code a SearchParams
-      // with its required `query` field missing.
-      return {
-        kind: 'search',
-        params: req.search
-      };
-    default:
-      {
-        const _exhaustive = req.reason;
-        throw new Error(`Unhandled GateReason: ${String(_exhaustive)}`);
-      }
-  }
-}
-
-// Native awaits this per request at a serve site.
-// No resolver → static gate → every request is gated (native applies stored default / built-in).
-nativeBrowser.resolveGate = async req => {
-  const result = resolver ? resolver(toPublicRequest(req)) : true;
-  if (result === false) return {
-    gated: false
-  };
-  if (result === true) return {
-    gated: true
-  };
-  return {
-    gated: true,
-    gate: result
-  };
-};
-
-// MARK: - Public API
-
-/**
- * Raises the gate with default chrome, optionally with a per-request resolver.
- * Calling it again while a gate is already up updates the chrome in place,
- * keeping the current tab. Note this is **not** fully navigation-preserving: on
- * some surfaces (CarPlay) any gate change pops pushed navigation back to root,
- * so a page the user had drilled into is reset to the tab root. Set the gate
- * before the car connects and it'll be there the moment it does.
- */
-
-/**
- * Raises the gate with a resolver only (no default chrome).
- * The resolver must return a {@link Gate} or `true` for gated requests;
- * native uses the built-in fallback chrome when `true` and no default is set.
- */
-
-export function setGate(a, b) {
-  if (typeof a === 'function') {
-    resolver = a;
-    nativeBrowser.setGate(undefined, true);
-  } else {
-    resolver = b;
-    nativeBrowser.setGate(a, b != null);
-  }
-}
-
-/**
- * Drops the gate — the real content comes back, and the current tab is kept.
- */
-export function clearGate() {
-  resolver = undefined;
-  nativeBrowser.clearGate();
-}
-
-/**
- * Subscribes to gate events (fired when a request is gated).
- * @returns An emitter — subscribe with `addListener(callback)`, which returns a cleanup function
- */
-export const onGate = LazyNativeEmitter.emitterize(cb => nativeBrowser.onGate = cb);
-//# sourceMappingURL=gate.js.map

package/lib/module/features/gate.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["nativeBrowser","LazyNativeEmitter","resolver","toPublicRequest","req","reason","kind","path","params","search","_exhaustive","Error","String","resolveGate","result","gated","gate","setGate","a","b","undefined","clearGate","onGate","emitterize","cb"],"sourceRoot":"../../../src","sources":["features/gate.ts"],"mappings":";;AACA,SAASA,aAAa,QAAQ,WAAW;AACzC,SAASC,iBAAiB,QAAQ,4BAA4B;;AAE9D;;AAEA;;AAGA;AACA;AACA;AACA;AACA;;AAOA;AACA;AACA;AACA;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAWA;AACA;AACA;AACA;;AAGA;AACA;AACA;AACA;AACA;;AAKA;AACA;AACA;AACA;AACA;AACA;;AAGA;;AAEA,IAAIC,QAAkC;AAEtC,SAASC,eAAeA,CAACC,GAAsB,EAAe;EAC5D,QAAQA,GAAG,CAACC,MAAM;IAChB,KAAK,QAAQ;MACX,OAAO;QAAEC,IAAI,EAAE,QAAQ;QAAEC,IAAI,EAAEH,GAAG,CAACG,IAAI,IAAI;MAAG,CAAC;IACjD,KAAK,QAAQ;MACX;MACA;MACA;MACA;MACA,OAAO;QAAED,IAAI,EAAE,QAAQ;QAAEE,MAAM,EAAEJ,GAAG,CAACK;MAAQ,CAAC;IAChD;MAAS;QACP,MAAMC,WAAkB,GAAGN,GAAG,CAACC,MAAM;QACrC,MAAM,IAAIM,KAAK,CAAC,yBAAyBC,MAAM,CAACF,WAAW,CAAC,EAAE,CAAC;MACjE;EACF;AACF;;AAEA;AACA;AACAV,aAAa,CAACa,WAAW,GAAG,MAC1BT,GAAsB,IACI;EAC1B,MAAMU,MAAM,GAAGZ,QAAQ,GAAGA,QAAQ,CAACC,eAAe,CAACC,GAAG,CAAC,CAAC,GAAG,IAAI;EAC/D,IAAIU,MAAM,KAAK,KAAK,EAAE,OAAO;IAAEC,KAAK,EAAE;EAAM,CAAC;EAC7C,IAAID,MAAM,KAAK,IAAI,EAAE,OAAO;IAAEC,KAAK,EAAE;EAAK,CAAC;EAC3C,OAAO;IAAEA,KAAK,EAAE,IAAI;IAAEC,IAAI,EAAEF;EAAO,CAAC;AACtC,CAAC;;AAED;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA,OAAO,SAASG,OAAOA,CAACC,CAAsB,EAAEC,CAAgB,EAAQ;EACtE,IAAI,OAAOD,CAAC,KAAK,UAAU,EAAE;IAC3BhB,QAAQ,GAAGgB,CAAC;IACZlB,aAAa,CAACiB,OAAO,CAACG,SAAS,EAAE,IAAI,CAAC;EACxC,CAAC,MAAM;IACLlB,QAAQ,GAAGiB,CAAC;IACZnB,aAAa,CAACiB,OAAO,CAACC,CAAC,EAAEC,CAAC,IAAI,IAAI,CAAC;EACrC;AACF;;AAEA;AACA;AACA;AACA,OAAO,SAASE,SAASA,CAAA,EAAS;EAChCnB,QAAQ,GAAGkB,SAAS;EACpBpB,aAAa,CAACqB,SAAS,CAAC,CAAC;AAC3B;;AAEA;AACA;AACA;AACA;AACA,OAAO,MAAMC,MAAM,GAAGrB,iBAAiB,CAACsB,UAAU,CAC/CC,EAAE,IAAMxB,aAAa,CAACsB,MAAM,GAAGE,EAClC,CAAC","ignoreList":[]}

package/lib/module/features/playback/trackPlaybackTime.js

@@ -1,83 +0,0 @@
-"use strict";
-
-import { nativeBrowser } from '../../native';
-import { onActiveTrackChanged } from '../queue/activeTrack';
-
-// MARK: - Types
-
-// MARK: - State
-
-const handles = new Set();
-let installed = false;
-let currentTrack;
-
-// The native tick fires once per second while playback is `playing` (and stops
-// while paused/buffering/stopped), so advancing each handle by one second per
-// tick yields cumulative *playback* time that freezes on interruption.
-function onTick() {
-  for (const handle of handles) {
-    handle.totalSeconds += 1;
-    const sinceLast = handle.totalSeconds - handle.lastFireSeconds;
-    if (sinceLast >= handle.period) {
-      handle.lastFireSeconds = handle.totalSeconds;
-      handle.callback({
-        total: handle.totalSeconds,
-        sinceLast,
-        track: currentTrack
-      });
-    }
-  }
-}
-function install() {
-  if (installed) return;
-  installed = true;
-  nativeBrowser.onPlaybackInterval = onTick;
-  onActiveTrackChanged.addListener(event => {
-    currentTrack = event.track;
-  });
-}
-
-// MARK: - Public API
-
-/**
- * Calls `callback` every `period` seconds of cumulative playback — time spent in
- * the `playing` state. The clock advances only while playing and freezes on
- * pause/buffering/stop, resuming where it left off; it is never reset (cancel and
- * re-subscribe for a fresh `total`). Coarse, best-effort cadence (~1s resolution),
- * not a precise timer.
- *
- * Typical use is a periodic "still listening" signal: fire an analytics ping, a
- * listen-check, or a heartbeat every N seconds of *actual* listening, so paused
- * time doesn't inflate the count.
- *
- * Note this counts cumulative play time across the whole session, NOT per track:
- * `total` keeps climbing through track changes, and `track` only tells you what
- * was playing at the moment each callback fired. To measure playtime per track,
- * subscribe to {@link onActiveTrackChanged} and cancel + re-subscribe here on each
- * change, so every track gets a fresh `total` starting at zero.
- *
- * @param callback Invoked once per elapsed `period`, with cumulative play time
- *                 and the currently playing track.
- * @param period  Seconds of playback between calls. Must be >= 1.
- * @returns A function that cancels this subscription (idempotent — safe to call
- *          more than once).
- */
-export function trackPlaybackTime(callback, period) {
-  if (!(period >= 1)) {
-    throw new Error('trackPlaybackTime: period must be >= 1');
-  }
-  install();
-  const handle = {
-    period,
-    totalSeconds: 0,
-    lastFireSeconds: 0,
-    callback
-  };
-  handles.add(handle);
-  if (handles.size === 1) nativeBrowser.setPlaybackIntervalEnabled(true);
-  return () => {
-    if (!handles.delete(handle)) return;
-    if (handles.size === 0) nativeBrowser.setPlaybackIntervalEnabled(false);
-  };
-}
-//# sourceMappingURL=trackPlaybackTime.js.map

package/lib/module/features/playback/trackPlaybackTime.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["nativeBrowser","onActiveTrackChanged","handles","Set","installed","currentTrack","onTick","handle","totalSeconds","sinceLast","lastFireSeconds","period","callback","total","track","install","onPlaybackInterval","addListener","event","trackPlaybackTime","Error","add","size","setPlaybackIntervalEnabled","delete"],"sourceRoot":"../../../../src","sources":["features/playback/trackPlaybackTime.ts"],"mappings":";;AACA,SAASA,aAAa,QAAQ,cAAc;AAC5C,SAASC,oBAAoB,QAAQ,sBAAsB;;AAE3D;;AAkBA;;AAEA,MAAMC,OAAO,GAAG,IAAIC,GAAG,CAAS,CAAC;AACjC,IAAIC,SAAS,GAAG,KAAK;AACrB,IAAIC,YAA+B;;AAEnC;AACA;AACA;AACA,SAASC,MAAMA,CAAA,EAAG;EAChB,KAAK,MAAMC,MAAM,IAAIL,OAAO,EAAE;IAC5BK,MAAM,CAACC,YAAY,IAAI,CAAC;IACxB,MAAMC,SAAS,GAAGF,MAAM,CAACC,YAAY,GAAGD,MAAM,CAACG,eAAe;IAC9D,IAAID,SAAS,IAAIF,MAAM,CAACI,MAAM,EAAE;MAC9BJ,MAAM,CAACG,eAAe,GAAGH,MAAM,CAACC,YAAY;MAC5CD,MAAM,CAACK,QAAQ,CAAC;QACdC,KAAK,EAAEN,MAAM,CAACC,YAAY;QAC1BC,SAAS;QACTK,KAAK,EAAET;MACT,CAAC,CAAC;IACJ;EACF;AACF;AAEA,SAASU,OAAOA,CAAA,EAAG;EACjB,IAAIX,SAAS,EAAE;EACfA,SAAS,GAAG,IAAI;EAChBJ,aAAa,CAACgB,kBAAkB,GAAGV,MAAM;EACzCL,oBAAoB,CAACgB,WAAW,CAAEC,KAAK,IAAK;IAC1Cb,YAAY,GAAGa,KAAK,CAACJ,KAAK;EAC5B,CAAC,CAAC;AACJ;;AAEA;;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,SAASK,iBAAiBA,CAC/BP,QAA4C,EAC5CD,MAAc,EACF;EACZ,IAAI,EAAEA,MAAM,IAAI,CAAC,CAAC,EAAE;IAClB,MAAM,IAAIS,KAAK,CAAC,wCAAwC,CAAC;EAC3D;EACAL,OAAO,CAAC,CAAC;EACT,MAAMR,MAAc,GAAG;IACrBI,MAAM;IACNH,YAAY,EAAE,CAAC;IACfE,eAAe,EAAE,CAAC;IAClBE;EACF,CAAC;EACDV,OAAO,CAACmB,GAAG,CAACd,MAAM,CAAC;EACnB,IAAIL,OAAO,CAACoB,IAAI,KAAK,CAAC,EAAEtB,aAAa,CAACuB,0BAA0B,CAAC,IAAI,CAAC;EACtE,OAAO,MAAM;IACX,IAAI,CAACrB,OAAO,CAACsB,MAAM,CAACjB,MAAM,CAAC,EAAE;IAC7B,IAAIL,OAAO,CAACoB,IAAI,KAAK,CAAC,EAAEtB,aAAa,CAACuB,0BAA0B,CAAC,KAAK,CAAC;EACzE,CAAC;AACH","ignoreList":[]}

package/lib/module/features/player/validateOptions.js

@@ -1,20 +0,0 @@
-"use strict";
-
-const MAX_CARPLAY_NOW_PLAYING_BUTTONS = 5;
-
-/**
- * Warns when more CarPlay now-playing buttons are configured than CarPlay renders.
- * Shared by `updateOptions` and `setupPlayer` (both can carry `ios` options).
- *
- * Lives outside `options.ts` because `features/player/index.ts` re-exports that
- * module wholesale: anything exported there joins the package's runtime surface,
- * `@internal` or not. This file is imported directly by the two callers and by
- * nothing in the barrel.
- */
-export function validateIOSUpdateOptions(ios) {
-  const buttons = ios?.carPlayNowPlayingButtons;
-  if (buttons && buttons.length > MAX_CARPLAY_NOW_PLAYING_BUTTONS) {
-    console.warn(`[react-native-audio-browser] ${buttons.length} CarPlay now-playing ` + `buttons configured; CarPlay shows at most ${MAX_CARPLAY_NOW_PLAYING_BUTTONS}.`);
-  }
-}
-//# sourceMappingURL=validateOptions.js.map

package/lib/module/features/player/validateOptions.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["MAX_CARPLAY_NOW_PLAYING_BUTTONS","validateIOSUpdateOptions","ios","buttons","carPlayNowPlayingButtons","length","console","warn"],"sourceRoot":"../../../../src","sources":["features/player/validateOptions.ts"],"mappings":";;AAEA,MAAMA,+BAA+B,GAAG,CAAC;;AAEzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,wBAAwBA,CAACC,GAAsB,EAAQ;EACrE,MAAMC,OAAO,GAAGD,GAAG,EAAEE,wBAAwB;EAC7C,IAAID,OAAO,IAAIA,OAAO,CAACE,MAAM,GAAGL,+BAA+B,EAAE;IAC/DM,OAAO,CAACC,IAAI,CACV,gCAAgCJ,OAAO,CAACE,MAAM,uBAAuB,GACnE,6CAA6CL,+BAA+B,GAChF,CAAC;EACH;AACF","ignoreList":[]}

package/lib/module/utils/artwork.js

@@ -1,26 +0,0 @@
-"use strict";
-
-/**
- * Whether a track's artwork ships one image per appearance.
- *
- * Narrows the union in one place, so nothing else has to know how it is
- * discriminated.
- */
-export function isArtworkVariants(artwork) {
-  return typeof artwork === 'object' && artwork !== null;
-}
-
-/**
- * The single artwork URL to use.
- *
- * Mirrors the Swift `Variant_String_ArtworkVariants.url` accessor: a pair
- * resolves to its dark URL unless a scheme is given, because dark is what a
- * single-URL track would have shipped and is the only appearance Android Auto
- * has. Callers that can render per appearance (CarPlay, via a `UIImageAsset`)
- * take the pair itself rather than going through this.
- */
-export function artworkUrl(artwork, scheme = 'dark') {
-  if (artwork === undefined) return undefined;
-  return isArtworkVariants(artwork) ? artwork[scheme] : artwork;
-}
-//# sourceMappingURL=artwork.js.map

package/lib/module/utils/artwork.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["isArtworkVariants","artwork","artworkUrl","scheme","undefined"],"sourceRoot":"../../../src","sources":["utils/artwork.ts"],"mappings":";;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASA,iBAAiBA,CAC/BC,OAAiC,EACL;EAC5B,OAAO,OAAOA,OAAO,KAAK,QAAQ,IAAIA,OAAO,KAAK,IAAI;AACxD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASC,UAAUA,CACxBD,OAAiC,EACjCE,MAAwB,GAAG,MAAM,EACb;EACpB,IAAIF,OAAO,KAAKG,SAAS,EAAE,OAAOA,SAAS;EAC3C,OAAOJ,iBAAiB,CAACC,OAAO,CAAC,GAAGA,OAAO,CAACE,MAAM,CAAC,GAAGF,OAAO;AAC/D","ignoreList":[]}

package/lib/module/web/TrackPlayer/PlaybackStateMachine.js

@@ -1,67 +0,0 @@
-"use strict";
-
-/**
- * Every racy observation that can move the playback state — the web analog of
- * iOS's `PlaybackEvent` / Android's `PlaybackEvent`. Each is produced by an
- * HTML5 `<audio>` or Shaka event:
- *
- * | event                | source                          |
- * |----------------------|---------------------------------|
- * | `trackLoading`       | Shaka `loading`                 |
- * | `loadSeekCompleted`  | Shaka `loaded`                  |
- * | `waiting`            | Shaka `buffering` (`true`)      |
- * | `bufferingSufficient`| Shaka `buffering` (`false`)     |
- * | `playing`            | element `playing`               |
- * | `paused`             | element `pause`                 |
- * | `trackEndedNaturally`| element `ended`                 |
- *
- * Deliberate *commands* (stop, error) set their terminal state directly rather
- * than flowing through here — they are intentions, not observations. The two
- * iOS-only events `trackUnloaded` and `audioFrameDecoded` are omitted: web has
- * no unload-to-none source, and a decoded frame is indistinguishable from
- * `playing` in the browser.
- */
-
-/**
- * The next playback state for an event from the current state, or `null` to
- * suppress the transition. A faithful port of iOS's `nextPlaybackState(from:on:)`.
- *
- * Guards here are **state-related** (e.g. "only from loading"). Context-related
- * guards (does an asset exist, near track end, playWhenReady) are decided at the
- * call site and arrive as event fields / whether the event fires at all.
- *
- * Pure: side effects (event emission, now-playing sync, timers, error payloads)
- * stay with the caller.
- */
-export function nextPlaybackState(current, event) {
-  switch (event.type) {
-    case 'trackLoading':
-      return 'loading';
-    case 'trackEndedNaturally':
-      return 'ended';
-    case 'waiting':
-      return 'buffering';
-    case 'playing':
-      return 'playing';
-    case 'loadSeekCompleted':
-      // The settle after a load; meaningless from anything but a fresh load.
-      return current === 'loading' ? 'ready' : null;
-    case 'paused':
-      // A stopped player owns its state; a stray pause must not disturb it.
-      if (current === 'stopped') return null;
-      // No asset means the element paused because it was emptied → nothing loaded.
-      if (!event.hasAsset) return 'none';
-      // Preserve a terminal error: the unload that follows an error pauses the
-      // element, and that pause must not clear the error the UI is rendering.
-      if (current === 'error') return null;
-      return 'paused';
-    case 'bufferingSufficient':
-      // A rebuffer that finishes mid-playback should stay playing, not flash
-      // ready. Terminal states must not drift back to ready either: from error
-      // it would silently clear the error the UI is rendering (Shaka's
-      // post-error unload emits buffering events without the stopped dispatch
-      // gate); ended/stopped own their state until an explicit load or play.
-      return current === 'playing' || current === 'ended' || current === 'stopped' || current === 'error' ? null : 'ready';
-  }
-}
-//# sourceMappingURL=PlaybackStateMachine.js.map

package/lib/module/web/TrackPlayer/PlaybackStateMachine.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["nextPlaybackState","current","event","type","hasAsset"],"sourceRoot":"../../../../src","sources":["web/TrackPlayer/PlaybackStateMachine.ts"],"mappings":";;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAUA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASA,iBAAiBA,CAC/BC,OAAsB,EACtBC,KAAoB,EACE;EACtB,QAAQA,KAAK,CAACC,IAAI;IAChB,KAAK,cAAc;MACjB,OAAO,SAAS;IAClB,KAAK,qBAAqB;MACxB,OAAO,OAAO;IAChB,KAAK,SAAS;MACZ,OAAO,WAAW;IACpB,KAAK,SAAS;MACZ,OAAO,SAAS;IAClB,KAAK,mBAAmB;MACtB;MACA,OAAOF,OAAO,KAAK,SAAS,GAAG,OAAO,GAAG,IAAI;IAC/C,KAAK,QAAQ;MACX;MACA,IAAIA,OAAO,KAAK,SAAS,EAAE,OAAO,IAAI;MACtC;MACA,IAAI,CAACC,KAAK,CAACE,QAAQ,EAAE,OAAO,MAAM;MAClC;MACA;MACA,IAAIH,OAAO,KAAK,OAAO,EAAE,OAAO,IAAI;MACpC,OAAO,QAAQ;IACjB,KAAK,qBAAqB;MACxB;MACA;MACA;MACA;MACA;MACA,OAAOA,OAAO,KAAK,SAAS,IAC1BA,OAAO,KAAK,OAAO,IACnBA,OAAO,KAAK,SAAS,IACrBA,OAAO,KAAK,OAAO,GACjB,IAAI,GACJ,OAAO;EACf;AACF","ignoreList":[]}

package/lib/module/web/TrackPlayer/PlaybackTimer.js

@@ -1,29 +0,0 @@
-"use strict";
-
-/**
- * A restartable interval timer that fires only while a gate predicate holds —
- * the web analog of Android's playback-state-gated `PlaybackTimer`. The timer
- * keeps running while the gate is closed; ticks are simply skipped, so it
- * resumes the moment the gate reopens (e.g. buffering → playing) without being
- * restarted.
- */
-export class PlaybackTimer {
-  /**
-   * (Re)starts the timer. Every `intervalMs` it calls `onTick`, but only when
-   * `shouldTick()` returns true. A non-positive interval leaves it stopped.
-   */
-  start(intervalMs, shouldTick, onTick) {
-    this.stop();
-    if (intervalMs <= 0) return;
-    this.handle = setInterval(() => {
-      if (shouldTick()) onTick();
-    }, intervalMs);
-  }
-  stop() {
-    if (this.handle !== undefined) {
-      clearInterval(this.handle);
-      this.handle = undefined;
-    }
-  }
-}
-//# sourceMappingURL=PlaybackTimer.js.map

package/lib/module/web/TrackPlayer/PlaybackTimer.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["PlaybackTimer","start","intervalMs","shouldTick","onTick","stop","handle","setInterval","undefined","clearInterval"],"sourceRoot":"../../../../src","sources":["web/TrackPlayer/PlaybackTimer.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,MAAMA,aAAa,CAAC;EAGzB;AACF;AACA;AACA;EACEC,KAAKA,CACHC,UAAkB,EAClBC,UAAyB,EACzBC,MAAkB,EACZ;IACN,IAAI,CAACC,IAAI,CAAC,CAAC;IACX,IAAIH,UAAU,IAAI,CAAC,EAAE;IACrB,IAAI,CAACI,MAAM,GAAGC,WAAW,CAAC,MAAM;MAC9B,IAAIJ,UAAU,CAAC,CAAC,EAAEC,MAAM,CAAC,CAAC;IAC5B,CAAC,EAAEF,UAAU,CAAC;EAChB;EAEAG,IAAIA,CAAA,EAAS;IACX,IAAI,IAAI,CAACC,MAAM,KAAKE,SAAS,EAAE;MAC7BC,aAAa,CAAC,IAAI,CAACH,MAAM,CAAC;MAC1B,IAAI,CAACA,MAAM,GAAGE,SAAS;IACzB;EACF;AACF","ignoreList":[]}

package/lib/module/web/TrackPlayer/PlayingStateFactory.js

@@ -1,17 +0,0 @@
-"use strict";
-
-/**
- * Derives the two-flag {@link PlayingState} (playing / buffering) from the
- * player's intent (`playWhenReady`) and its current {@link PlaybackState}.
- *
- * A faithful port of the native derivations (android `PlayingStateFactory.derive`,
- * ios `PlayingStateManager.update`) so all platforms agree on what "playing" and
- * "buffering" mean for the now-playing UI.
- */
-export function derivePlayingState(playWhenReady, state) {
-  return {
-    playing: playWhenReady && state !== 'error' && state !== 'ended' && state !== 'none' && state !== 'stopped',
-    buffering: playWhenReady && (state === 'loading' || state === 'buffering')
-  };
-}
-//# sourceMappingURL=PlayingStateFactory.js.map

package/lib/module/web/TrackPlayer/PlayingStateFactory.js.map

@@ -1 +0,0 @@
-{"version":3,"names":["derivePlayingState","playWhenReady","state","playing","buffering"],"sourceRoot":"../../../../src","sources":["web/TrackPlayer/PlayingStateFactory.ts"],"mappings":";;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASA,kBAAkBA,CAChCC,aAAsB,EACtBC,KAAoB,EACN;EACd,OAAO;IACLC,OAAO,EACLF,aAAa,IACbC,KAAK,KAAK,OAAO,IACjBA,KAAK,KAAK,OAAO,IACjBA,KAAK,KAAK,MAAM,IAChBA,KAAK,KAAK,SAAS;IACrBE,SAAS,EAAEH,aAAa,KAAKC,KAAK,KAAK,SAAS,IAAIA,KAAK,KAAK,WAAW;EAC3E,CAAC;AACH","ignoreList":[]}