react-native-hls-cache 0.1.0 → 0.2.0

package/README.md

@@ -1,233 +1,73 @@
 # react-native-hls-cache
 
-HLS video caching for React Native — intercepts segment requests via a local TCP proxy, caches them to disk, and serves subsequent playback from cache.
-
-- **iOS** — full proxy implementation (Swift, Network framework)
-- **Android** — no-op; ExoPlayer/Media3 handle caching natively
-- **Bridge** — [Nitro Modules](https://nitro.margelo.com/) (type-safe FFI)
-
----
+HSL
 
 ## Installation
 
+
 ```sh
 npm install react-native-hls-cache react-native-nitro-modules
-# or
-yarn add react-native-hls-cache react-native-nitro-modules
-```
-
-> `react-native-nitro-modules` is a required peer dependency.
-
----
-
-## Quick Start
-
-```tsx
-import { startServer, convertUrl } from 'react-native-hls-cache';
-import { useVideoPlayer, VideoView } from 'expo-video';
-import { useEffect } from 'react';
 
-export default function App() {
-  useEffect(() => {
-    // Start the proxy once on app launch
-    startServer();
-  }, []);
-
-  const remoteUrl = 'https://stream.mux.com/abc123.m3u8';
-
-  const player = useVideoPlayer(
-    convertUrl(remoteUrl), // rewrites to http://127.0.0.1:9000/proxy?url=...
-    (p) => { p.loop = true; }
-  );
-
-  return <VideoView player={player} style={{ flex: 1 }} />;
-}
+> `react-native-nitro-modules` is required as this library relies on [Nitro Modules](https://nitro.margelo.com/).
 ```
 
----
 
-## API
+## Usage
 
-### `startServer(port?, maxCacheSize?, headOnlyCache?)`
 
-Starts the local HLS proxy server. Call once on app mount.
+```js
+import { multiply } from 'react-native-hls-cache';
 
-| Parameter | Type | Default | Description |
-|---|---|---|---|
-| `port` | `number` | `9000` | Local TCP port to bind |
-| `maxCacheSize` | `number` | `1073741824` | Max disk cache in bytes (1 GB) |
-| `headOnlyCache` | `boolean` | `false` | Only cache the first 3 segments per stream. Recommended for vertical video feeds |
+// ...
 
-```ts
-startServer();                          // defaults
-startServer(9000, 512 * 1024 * 1024);  // 512 MB cache
-startServer(9000, undefined, true);     // head-only mode for feeds
+const result = multiply(3, 7);
 ```
 
-- Synchronous and fast (< 1ms) — does not block the JS thread
-- Safe to call multiple times; no-op if already running on the same port
-- Throws with code `409` if a server is already running on a different port
-- No-op on Android / Web
-
----
-
-### `convertUrl(url, isCacheable?)`
-
-Rewrites a remote HLS URL to route through the local proxy.
-
-```ts
-const localUrl = convertUrl('https://cdn.example.com/video.m3u8');
-// → 'http://127.0.0.1:9000/proxy?url=https%3A%2F%2Fcdn.example.com%2Fvideo.m3u8'
-```
-
-| Parameter | Type | Default | Description |
-|---|---|---|---|
-| `url` | `string` | — | Remote HLS URL |
-| `isCacheable` | `boolean` | `true` | Pass `false` to bypass the proxy and return the original URL |
-
-- Returns the original URL unchanged on Android / Web, or if the server is not running
-- Synchronous — safe to call inline during render
-
----
-
-### `clearCache()`
-
-Deletes all cached files from disk.
-
-```ts
-await clearCache();
-```
-
-- Runs on a background thread — does not block the JS thread
-- No-op on Android / Web
-
----
-
-### `prefetch(url, segmentCount?)`
-
-Downloads an HLS stream into cache before the user plays it. Returns a `taskId` for cancellation.
-
-```ts
-const taskId = prefetch('https://cdn.example.com/video.m3u8');
-const taskId = prefetch('https://cdn.example.com/video.m3u8', 5); // cache 5 segments
-```
-
-| Parameter | Type | Default | Description |
-|---|---|---|---|
-| `url` | `string` | — | Remote HLS URL |
-| `segmentCount` | `number` | `3` | Number of segments to prefetch |
-
-**What it does:**
-1. Downloads the master playlist
-2. Picks the lowest-bandwidth media playlist (lightweight for background work)
-3. Downloads the first `segmentCount` segments into the disk cache
-4. When the player requests those segments via the proxy → instant cache hit
 
-- Returns immediately — all work happens in the background
-- Returns `''` on Android / Web (no-op)
-
----
+## Contributing
 
-### `cancelPrefetch(taskId)`
+- [Development workflow](CONTRIBUTING.md#development-workflow)
+- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
+- [Code of conduct](CODE_OF_CONDUCT.md)
 
-Cancels a specific prefetch task.
+## License
 
-```ts
-const taskId = prefetch(url);
-// later...
-cancelPrefetch(taskId);
-```
+MIT
 
 ---
 
-### `cancelAllPrefetch()`
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)
 
-Cancels all active prefetch tasks.
 
-```ts
-cancelAllPrefetch();
-```
 
----
+Looking at the current API (startServer, convertUrl, clearCache) and the internals, here's what would genuinely add value:
 
-## Patterns
+High Value
+stopServer()
+There's no way to stop the proxy from JS. Needed for cleanup on app background/logout.
 
-### Vertical video feed (TikTok-style)
+getCacheStats() → { sizeBytes, fileCount, hitRate }
+Developers need this to show cache info in settings screens and debug eviction behavior. The storage layer already has all the data.
 
-```tsx
-import { startServer, convertUrl, prefetch, cancelAllPrefetch } from 'react-native-hls-cache';
+invalidateUrl(url)
+Right now clearCache() is all-or-nothing. Evicting a single video (e.g. when content is updated server-side) is a very common need.
 
-// App.tsx — start with head-only cache to minimise storage on feeds
-useEffect(() => {
-  startServer(9000, 512 * 1024 * 1024, true);
-  return () => cancelAllPrefetch();
-}, []);
+prefetch(url)
+Download a video into cache before the user plays it. The NetworkDownloader + DataSource pipeline is already there — this would just drive it without a proxy connection. Big UX win for predictable playback.
 
-// VideoItem.tsx — prefetch the next video as the user scrolls
-useEffect(() => {
-  if (shouldPreload) {
-    const taskId = prefetch(videoUrl);
-    return () => cancelPrefetch(taskId);
-  }
-}, [shouldPreload, videoUrl]);
+Medium Value
+isRunning: boolean property
+JS callers currently have no way to check server state without trying to start it and catching an error.
 
-const player = useVideoPlayer(convertUrl(videoUrl), (p) => {
-  p.loop = true;
-});
-```
+WiFi-only caching option
+A wifiOnly flag on startServer — skip disk writes on cellular to avoid burning mobile data.
 
-### Selective caching
+Cache event callbacks onCacheHit / onCacheMiss
+Useful for analytics (measuring actual cache efficiency in production).
 
-```ts
-// Skip cache for live streams or DRM content
-const url = convertUrl(streamUrl, !isLive && !isDRM);
-```
+Lower Priority
+Configurable cache directory — some apps have specific storage requirements (e.g. store in Documents for user-visible files vs Caches).
 
-### Clear cache on logout
+Resume interrupted downloads — if a segment write was interrupted (app killed mid-download), the current code deletes it and re-fetches. A partial-resume strategy would save bandwidth for large segments.
 
-```ts
-async function onLogout() {
-  cancelAllPrefetch();
-  await clearCache();
-}
-```
-
----
-
-## How It Works
-
-```
-Media Player
-  → HTTP request to localhost:9000/proxy?url=<encoded>
-  → VideoProxyServer (NWListener, TCP)
-  → ClientConnectionHandler (per-connection HTTP handler)
-  → DataSource (cache-first router)
-      ├── Cache hit  → memory-mapped read from disk → instant response
-      └── Cache miss → NetworkDownloader (priority queue, 32 concurrent)
-                           → stream to player + write to disk simultaneously
-```
-
-**Cache storage** — files are keyed by SHA256 hash of the URL (+ byte range for fMP4 segments), stored in the system Caches directory under `ExpoVideoCache/`. LRU eviction runs 5 seconds after server start.
-
-**Manifest rewriting** — `.m3u8` responses are intercepted and all segment URLs are rewritten to route through the proxy, so every subsequent segment request is also cacheable.
-
-**Priority queue** — `.m3u8` manifests and small requests bypass the concurrency semaphore for instant playback startup. Heavy segment downloads are queued with a limit of 32 concurrent connections.
-
----
-
-## Requirements
-
-- React Native 0.73+
-- iOS 15.1+
-- Android — no native requirements (no-op)
-
----
-
-## Contributing
-
-- [Development workflow](CONTRIBUTING.md#development-workflow)
-- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
-
-## License
-
-MIT
+The three I'd ship first: stopServer, getCacheStats, and prefetch — they cover the most common real-world gaps without requiring deep architectural changes.

package/android/src/main/java/com/margelo/nitro/hlscache/HlsCache.kt

@@ -21,12 +21,4 @@ class HlsCache : HybridHlsCacheSpec() {
     override fun clearCache(): Promise<Unit> {
         return Promise.resolved(Unit)
     }
-
-    override fun prefetch(url: String, segmentCount: Double?): String {
-        return ""
-    }
-
-    override fun cancelPrefetch(taskId: String): Unit {}
-
-    override fun cancelAllPrefetch(): Unit {}
 }

package/ios/DataSource.swift

@@ -100,14 +100,7 @@ internal final class DataSource: NetworkDownloaderDelegate {
             }
             return
         }
-
-        // Range-keyed file not found — fall back to the full file that prefetch may have
-        // stored without a range suffix. Slice the requested bytes out of it on the fly.
-        if range != nil && !isManifest && storage.exists(for: url.absoluteString) {
-            DataSource.diskQueue.async { self.serveRangeFromFullFile() }
-            return
-        }
-
+        
         if isManifest {
             downloadManifest()
         } else {
@@ -179,37 +172,6 @@ internal final class DataSource: NetworkDownloaderDelegate {
         delegate?.didComplete(error: nil)
     }
     
-    /// Serves a byte-range slice from a full file that was cached by prefetch (no range suffix).
-    private func serveRangeFromFullFile() {
-        let path = storage.getFilePath(for: url.absoluteString)
-        guard let fullData = try? Data(contentsOf: path, options: .mappedIfSafe),
-              let r = range else {
-            // Full file unreadable — fall through to network.
-            startStreamDownload()
-            return
-        }
-
-        let fileSize = fullData.count
-        let lower = r.lowerBound
-        let upper = r.upperBound == Int.max ? fileSize : min(r.upperBound, fileSize)
-
-        guard lower < fileSize else {
-            delegate?.didComplete(error: NSError(domain: "RangeError", code: 416))
-            return
-        }
-
-        let sliced = Data(fullData[lower..<upper])
-        let headers: [String: String] = [
-            "Content-Type": getMimeType(url: url),
-            "Content-Length": "\(sliced.count)",
-            "Accept-Ranges": "bytes",
-            "Content-Range": "bytes \(lower)-\(upper - 1)/\(fileSize)"
-        ]
-        delegate?.didReceiveHeaders(headers: headers, status: 206)
-        delegate?.didReceiveData(data: sliced)
-        delegate?.didComplete(error: nil)
-    }
-
     // MARK: - Network Path (Cache Miss)
     
     private func startStreamDownload() {

package/ios/HlsCache.swift

@@ -76,6 +76,7 @@ public class HybridHlsCache: HybridHlsCacheSpec {
 
     /// Heavy async method — file I/O runs on a background thread via Promise.async.
     public func clearCache() throws -> Promise<Void> {
+        // Capture server ref synchronously (JS thread) before jumping to background.
         stateLock.lock()
         let server = proxyServer
         stateLock.unlock()
@@ -88,34 +89,4 @@ public class HybridHlsCache: HybridHlsCacheSpec {
             }
         }
     }
-
-    /// Prefetches an HLS stream into cache. Returns a taskId for cancellation.
-    /// Runs entirely in the background — JS thread returns immediately.
-    public func prefetch(url: String, segmentCount: Double?) throws -> String {
-        guard let parsedURL = URL(string: url) else {
-            throw NSError(
-                domain: "HlsCache",
-                code: 400,
-                userInfo: [NSLocalizedDescriptionKey: "Invalid URL: \(url)"]
-            )
-        }
-
-        stateLock.lock()
-        let server = proxyServer
-        stateLock.unlock()
-
-        // Reuse the server's storage if running, otherwise create a temporary one.
-        let storage = server?.storage ?? VideoCacheStorage(maxCacheSize: 1_073_741_824)
-        let count = segmentCount.map { Int($0) } ?? 3
-
-        return PrefetchManager.shared.prefetch(url: parsedURL, storage: storage, segmentCount: count)
-    }
-
-    public func cancelPrefetch(taskId: String) throws -> Void {
-        PrefetchManager.shared.cancel(taskId: taskId)
-    }
-
-    public func cancelAllPrefetch() throws -> Void {
-        PrefetchManager.shared.cancelAll()
-    }
 }

package/ios/VideoProxyServer.swift

@@ -25,7 +25,7 @@ internal final class VideoProxyServer: ProxyConnectionDelegate {
     private var listener: NWListener?
     
     /// Disk-backed storage used for caching video data.
-    internal let storage: VideoCacheStorage
+    private let storage: VideoCacheStorage
     
     /// The local port on which the server listens for incoming connections.
     internal let port: Int

package/lib/module/index.js

@@ -41,31 +41,4 @@ export function clearCache() {
   if (Platform.OS !== 'ios') return Promise.resolve();
   return getInstance().clearCache();
 }
-
-/**
- * Prefetches an HLS stream into the local cache in the background.
- * Downloads the manifest + first `segmentCount` segments (default: 3).
- *
- * @returns A taskId that can be passed to `cancelPrefetch` to stop the download.
- */
-export function prefetch(url, segmentCount) {
-  if (Platform.OS !== 'ios') return '';
-  return getInstance().prefetch(url, segmentCount);
-}
-
-/**
- * Cancels a specific prefetch task by its taskId.
- */
-export function cancelPrefetch(taskId) {
-  if (Platform.OS !== 'ios') return;
-  getInstance().cancelPrefetch(taskId);
-}
-
-/**
- * Cancels all active prefetch tasks.
- */
-export function cancelAllPrefetch() {
-  if (Platform.OS !== 'ios') return;
-  getInstance().cancelAllPrefetch();
-}
 //# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["NitroModules","Platform","_instance","getInstance","createHybridObject","startServer","port","maxCacheSize","headOnlyCache","OS","convertUrl","url","isCacheable","clearCache","Promise","resolve","prefetch","segmentCount","cancelPrefetch","taskId","cancelAllPrefetch"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AACzD,SAASC,QAAQ,QAAQ,cAAc;AAGvC,IAAIC,SAA0B,GAAG,IAAI;AAErC,SAASC,WAAWA,CAAA,EAAa;EAC/B,IAAID,SAAS,IAAI,IAAI,EAAE;IACrBA,SAAS,GAAGF,YAAY,CAACI,kBAAkB,CAAW,UAAU,CAAC;EACnE;EACA,OAAOF,SAAS;AAClB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASG,WAAWA,CACzBC,IAAa,EACbC,YAAqB,EACrBC,aAAuB,EACjB;EACN,IAAIP,QAAQ,CAACQ,EAAE,KAAK,KAAK,EAAE;EAC3BN,WAAW,CAAC,CAAC,CAACE,WAAW,CAACC,IAAI,EAAEC,YAAY,EAAEC,aAAa,CAAC;AAC9D;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASE,UAAUA,CAACC,GAAW,EAAEC,WAAqB,EAAU;EACrE,IAAIX,QAAQ,CAACQ,EAAE,KAAK,KAAK,EAAE,OAAOE,GAAG;EACrC,OAAOR,WAAW,CAAC,CAAC,CAACO,UAAU,CAACC,GAAG,EAAEC,WAAW,CAAC;AACnD;;AAEA;AACA;AACA;AACA,OAAO,SAASC,UAAUA,CAAA,EAAkB;EAC1C,IAAIZ,QAAQ,CAACQ,EAAE,KAAK,KAAK,EAAE,OAAOK,OAAO,CAACC,OAAO,CAAC,CAAC;EACnD,OAAOZ,WAAW,CAAC,CAAC,CAACU,UAAU,CAAC,CAAC;AACnC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASG,QAAQA,CAACL,GAAW,EAAEM,YAAqB,EAAU;EACnE,IAAIhB,QAAQ,CAACQ,EAAE,KAAK,KAAK,EAAE,OAAO,EAAE;EACpC,OAAON,WAAW,CAAC,CAAC,CAACa,QAAQ,CAACL,GAAG,EAAEM,YAAY,CAAC;AAClD;;AAEA;AACA;AACA;AACA,OAAO,SAASC,cAAcA,CAACC,MAAc,EAAQ;EACnD,IAAIlB,QAAQ,CAACQ,EAAE,KAAK,KAAK,EAAE;EAC3BN,WAAW,CAAC,CAAC,CAACe,cAAc,CAACC,MAAM,CAAC;AACtC;;AAEA;AACA;AACA;AACA,OAAO,SAASC,iBAAiBA,CAAA,EAAS;EACxC,IAAInB,QAAQ,CAACQ,EAAE,KAAK,KAAK,EAAE;EAC3BN,WAAW,CAAC,CAAC,CAACiB,iBAAiB,CAAC,CAAC;AACnC","ignoreList":[]}
+{"version":3,"names":["NitroModules","Platform","_instance","getInstance","createHybridObject","startServer","port","maxCacheSize","headOnlyCache","OS","convertUrl","url","isCacheable","clearCache","Promise","resolve"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AACzD,SAASC,QAAQ,QAAQ,cAAc;AAGvC,IAAIC,SAA0B,GAAG,IAAI;AAErC,SAASC,WAAWA,CAAA,EAAa;EAC/B,IAAID,SAAS,IAAI,IAAI,EAAE;IACrBA,SAAS,GAAGF,YAAY,CAACI,kBAAkB,CAAW,UAAU,CAAC;EACnE;EACA,OAAOF,SAAS;AAClB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASG,WAAWA,CACzBC,IAAa,EACbC,YAAqB,EACrBC,aAAuB,EACjB;EACN,IAAIP,QAAQ,CAACQ,EAAE,KAAK,KAAK,EAAE;EAC3BN,WAAW,CAAC,CAAC,CAACE,WAAW,CAACC,IAAI,EAAEC,YAAY,EAAEC,aAAa,CAAC;AAC9D;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASE,UAAUA,CAACC,GAAW,EAAEC,WAAqB,EAAU;EACrE,IAAIX,QAAQ,CAACQ,EAAE,KAAK,KAAK,EAAE,OAAOE,GAAG;EACrC,OAAOR,WAAW,CAAC,CAAC,CAACO,UAAU,CAACC,GAAG,EAAEC,WAAW,CAAC;AACnD;;AAEA;AACA;AACA;AACA,OAAO,SAASC,UAAUA,CAAA,EAAkB;EAC1C,IAAIZ,QAAQ,CAACQ,EAAE,KAAK,KAAK,EAAE,OAAOK,OAAO,CAACC,OAAO,CAAC,CAAC;EACnD,OAAOZ,WAAW,CAAC,CAAC,CAACU,UAAU,CAAC,CAAC;AACnC","ignoreList":[]}

package/lib/typescript/src/HlsCache.nitro.d.ts

@@ -6,8 +6,5 @@ export interface HlsCache extends HybridObject<{
     startServer(port?: number, maxCacheSize?: number, headOnlyCache?: boolean): void;
     convertUrl(url: string, isCacheable?: boolean): string;
     clearCache(): Promise<void>;
-    prefetch(url: string, segmentCount?: number): string;
-    cancelPrefetch(taskId: string): void;
-    cancelAllPrefetch(): void;
 }
 //# sourceMappingURL=HlsCache.nitro.d.ts.map

package/lib/typescript/src/HlsCache.nitro.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HlsCache.nitro.d.ts","sourceRoot":"","sources":["../../../src/HlsCache.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D,MAAM,WAAW,QACf,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACzD,WAAW,CACT,IAAI,CAAC,EAAE,MAAM,EACb,YAAY,CAAC,EAAE,MAAM,EACrB,aAAa,CAAC,EAAE,OAAO,GACtB,IAAI,CAAC;IACR,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IACvD,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACrD,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,iBAAiB,IAAI,IAAI,CAAC;CAC3B"}
+{"version":3,"file":"HlsCache.nitro.d.ts","sourceRoot":"","sources":["../../../src/HlsCache.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D,MAAM,WAAW,QACf,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACzD,WAAW,CACT,IAAI,CAAC,EAAE,MAAM,EACb,YAAY,CAAC,EAAE,MAAM,EACrB,aAAa,CAAC,EAAE,OAAO,GACtB,IAAI,CAAC;IACR,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IACvD,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC7B"}

package/lib/typescript/src/index.d.ts

@@ -18,19 +18,4 @@ export declare function convertUrl(url: string, isCacheable?: boolean): string;
  * Purges all cached video files from disk.
  */
 export declare function clearCache(): Promise<void>;
-/**
- * Prefetches an HLS stream into the local cache in the background.
- * Downloads the manifest + first `segmentCount` segments (default: 3).
- *
- * @returns A taskId that can be passed to `cancelPrefetch` to stop the download.
- */
-export declare function prefetch(url: string, segmentCount?: number): string;
-/**
- * Cancels a specific prefetch task by its taskId.
- */
-export declare function cancelPrefetch(taskId: string): void;
-/**
- * Cancels all active prefetch tasks.
- */
-export declare function cancelAllPrefetch(): void;
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAaA;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,IAAI,CAAC,EAAE,MAAM,EACb,YAAY,CAAC,EAAE,MAAM,EACrB,aAAa,CAAC,EAAE,OAAO,GACtB,IAAI,CAGN;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,OAAO,GAAG,MAAM,CAGrE;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAG1C;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAGnE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAGnD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAGxC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAaA;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,IAAI,CAAC,EAAE,MAAM,EACb,YAAY,CAAC,EAAE,MAAM,EACrB,aAAa,CAAC,EAAE,OAAO,GACtB,IAAI,CAGN;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,OAAO,GAAG,MAAM,CAGrE;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAG1C"}

package/nitrogen/generated/android/c++/JHybridHlsCacheSpec.cpp

@@ -72,18 +72,5 @@ namespace margelo::nitro::hlscache {
       return __promise;
     }();
   }
-  std::string JHybridHlsCacheSpec::prefetch(const std::string& url, std::optional<double> segmentCount) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JString>(jni::alias_ref<jni::JString> /* url */, jni::alias_ref<jni::JDouble> /* segmentCount */)>("prefetch");
-    auto __result = method(_javaPart, jni::make_jstring(url), segmentCount.has_value() ? jni::JDouble::valueOf(segmentCount.value()) : nullptr);
-    return __result->toStdString();
-  }
-  void JHybridHlsCacheSpec::cancelPrefetch(const std::string& taskId) {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<jni::JString> /* taskId */)>("cancelPrefetch");
-    method(_javaPart, jni::make_jstring(taskId));
-  }
-  void JHybridHlsCacheSpec::cancelAllPrefetch() {
-    static const auto method = _javaPart->javaClassStatic()->getMethod<void()>("cancelAllPrefetch");
-    method(_javaPart);
-  }
 
 } // namespace margelo::nitro::hlscache

package/nitrogen/generated/android/c++/JHybridHlsCacheSpec.hpp

@@ -57,9 +57,6 @@ namespace margelo::nitro::hlscache {
     void startServer(std::optional<double> port, std::optional<double> maxCacheSize, std::optional<bool> headOnlyCache) override;
     std::string convertUrl(const std::string& url, std::optional<bool> isCacheable) override;
     std::shared_ptr<Promise<void>> clearCache() override;
-    std::string prefetch(const std::string& url, std::optional<double> segmentCount) override;
-    void cancelPrefetch(const std::string& taskId) override;
-    void cancelAllPrefetch() override;
 
   private:
     jni::global_ref<JHybridHlsCacheSpec::JavaPart> _javaPart;

package/nitrogen/generated/android/kotlin/com/margelo/nitro/hlscache/HybridHlsCacheSpec.kt

@@ -40,18 +40,6 @@ abstract class HybridHlsCacheSpec: HybridObject() {
   @DoNotStrip
   @Keep
   abstract fun clearCache(): Promise<Unit>
-  
-  @DoNotStrip
-  @Keep
-  abstract fun prefetch(url: String, segmentCount: Double?): String
-  
-  @DoNotStrip
-  @Keep
-  abstract fun cancelPrefetch(taskId: String): Unit
-  
-  @DoNotStrip
-  @Keep
-  abstract fun cancelAllPrefetch(): Unit
 
   // Default implementation of `HybridObject.toString()`
   override fun toString(): String {

package/nitrogen/generated/ios/c++/HybridHlsCacheSpecSwift.hpp

@@ -90,26 +90,6 @@ namespace margelo::nitro::hlscache {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::string prefetch(const std::string& url, std::optional<double> segmentCount) override {
-      auto __result = _swiftPart.prefetch(url, segmentCount);
-      if (__result.hasError()) [[unlikely]] {
-        std::rethrow_exception(__result.error());
-      }
-      auto __value = std::move(__result.value());
-      return __value;
-    }
-    inline void cancelPrefetch(const std::string& taskId) override {
-      auto __result = _swiftPart.cancelPrefetch(taskId);
-      if (__result.hasError()) [[unlikely]] {
-        std::rethrow_exception(__result.error());
-      }
-    }
-    inline void cancelAllPrefetch() override {
-      auto __result = _swiftPart.cancelAllPrefetch();
-      if (__result.hasError()) [[unlikely]] {
-        std::rethrow_exception(__result.error());
-      }
-    }
 
   private:
     HlsCache::HybridHlsCacheSpec_cxx _swiftPart;

package/nitrogen/generated/ios/swift/HybridHlsCacheSpec.swift

@@ -16,9 +16,6 @@ public protocol HybridHlsCacheSpec_protocol: HybridObject {
   func startServer(port: Double?, maxCacheSize: Double?, headOnlyCache: Bool?) throws -> Void
   func convertUrl(url: String, isCacheable: Bool?) throws -> String
   func clearCache() throws -> Promise<Void>
-  func prefetch(url: String, segmentCount: Double?) throws -> String
-  func cancelPrefetch(taskId: String) throws -> Void
-  func cancelAllPrefetch() throws -> Void
 }
 
 public extension HybridHlsCacheSpec_protocol {

package/nitrogen/generated/ios/swift/HybridHlsCacheSpec_cxx.swift

@@ -193,45 +193,4 @@ open class HybridHlsCacheSpec_cxx {
       return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
-  
-  @inline(__always)
-  public final func prefetch(url: std.string, segmentCount: bridge.std__optional_double_) -> bridge.Result_std__string_ {
-    do {
-      let __result = try self.__implementation.prefetch(url: String(url), segmentCount: { () -> Double? in
-        if bridge.has_value_std__optional_double_(segmentCount) {
-          let __unwrapped = bridge.get_std__optional_double_(segmentCount)
-          return __unwrapped
-        } else {
-          return nil
-        }
-      }())
-      let __resultCpp = std.string(__result)
-      return bridge.create_Result_std__string_(__resultCpp)
-    } catch (let __error) {
-      let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_std__string_(__exceptionPtr)
-    }
-  }
-  
-  @inline(__always)
-  public final func cancelPrefetch(taskId: std.string) -> bridge.Result_void_ {
-    do {
-      try self.__implementation.cancelPrefetch(taskId: String(taskId))
-      return bridge.create_Result_void_()
-    } catch (let __error) {
-      let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
-    }
-  }
-  
-  @inline(__always)
-  public final func cancelAllPrefetch() -> bridge.Result_void_ {
-    do {
-      try self.__implementation.cancelAllPrefetch()
-      return bridge.create_Result_void_()
-    } catch (let __error) {
-      let __exceptionPtr = __error.toCpp()
-      return bridge.create_Result_void_(__exceptionPtr)
-    }
-  }
 }

package/nitrogen/generated/shared/c++/HybridHlsCacheSpec.cpp

@@ -17,9 +17,6 @@ namespace margelo::nitro::hlscache {
       prototype.registerHybridMethod("startServer", &HybridHlsCacheSpec::startServer);
       prototype.registerHybridMethod("convertUrl", &HybridHlsCacheSpec::convertUrl);
       prototype.registerHybridMethod("clearCache", &HybridHlsCacheSpec::clearCache);
-      prototype.registerHybridMethod("prefetch", &HybridHlsCacheSpec::prefetch);
-      prototype.registerHybridMethod("cancelPrefetch", &HybridHlsCacheSpec::cancelPrefetch);
-      prototype.registerHybridMethod("cancelAllPrefetch", &HybridHlsCacheSpec::cancelAllPrefetch);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridHlsCacheSpec.hpp

@@ -53,9 +53,6 @@ namespace margelo::nitro::hlscache {
       virtual void startServer(std::optional<double> port, std::optional<double> maxCacheSize, std::optional<bool> headOnlyCache) = 0;
       virtual std::string convertUrl(const std::string& url, std::optional<bool> isCacheable) = 0;
       virtual std::shared_ptr<Promise<void>> clearCache() = 0;
-      virtual std::string prefetch(const std::string& url, std::optional<double> segmentCount) = 0;
-      virtual void cancelPrefetch(const std::string& taskId) = 0;
-      virtual void cancelAllPrefetch() = 0;
 
     protected:
       // Hybrid Setup

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-hls-cache",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "HSL",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/HlsCache.nitro.ts

@@ -9,7 +9,4 @@ export interface HlsCache
   ): void;
   convertUrl(url: string, isCacheable?: boolean): string;
   clearCache(): Promise<void>;
-  prefetch(url: string, segmentCount?: number): string;
-  cancelPrefetch(taskId: string): void;
-  cancelAllPrefetch(): void;
 }

package/src/index.tsx

@@ -46,30 +46,3 @@ export function clearCache(): Promise<void> {
   if (Platform.OS !== 'ios') return Promise.resolve();
   return getInstance().clearCache();
 }
-
-/**
- * Prefetches an HLS stream into the local cache in the background.
- * Downloads the manifest + first `segmentCount` segments (default: 3).
- *
- * @returns A taskId that can be passed to `cancelPrefetch` to stop the download.
- */
-export function prefetch(url: string, segmentCount?: number): string {
-  if (Platform.OS !== 'ios') return '';
-  return getInstance().prefetch(url, segmentCount);
-}
-
-/**
- * Cancels a specific prefetch task by its taskId.
- */
-export function cancelPrefetch(taskId: string): void {
-  if (Platform.OS !== 'ios') return;
-  getInstance().cancelPrefetch(taskId);
-}
-
-/**
- * Cancels all active prefetch tasks.
- */
-export function cancelAllPrefetch(): void {
-  if (Platform.OS !== 'ios') return;
-  getInstance().cancelAllPrefetch();
-}

package/ios/PrefetchManager.swift

@@ -1,235 +0,0 @@
-import Foundation
-
-/// Manages background prefetch tasks for HLS streams.
-///
-/// Each prefetch task downloads the manifest + first N segments into the disk cache
-/// so they are instantly served from cache when the video player requests them.
-internal final class PrefetchManager {
-
-    static let shared = PrefetchManager()
-
-    private let lock = NSLock()
-    private var activeTasks: [String: PrefetchTask] = [:]
-
-    /// Starts prefetching an HLS stream. Returns a taskId that can be used to cancel.
-    func prefetch(url: URL, storage: VideoCacheStorage, segmentCount: Int) -> String {
-        let taskId = UUID().uuidString
-        let task = PrefetchTask(url: url, storage: storage, segmentCount: segmentCount)
-
-        lock.lock()
-        activeTasks[taskId] = task
-        lock.unlock()
-
-        task.start { [weak self] in
-            self?.lock.lock()
-            self?.activeTasks.removeValue(forKey: taskId)
-            self?.lock.unlock()
-        }
-
-        return taskId
-    }
-
-    func cancel(taskId: String) {
-        lock.lock()
-        let task = activeTasks.removeValue(forKey: taskId)
-        lock.unlock()
-        task?.cancel()
-    }
-
-    func cancelAll() {
-        lock.lock()
-        let tasks = Array(activeTasks.values)
-        activeTasks.removeAll()
-        lock.unlock()
-        tasks.forEach { $0.cancel() }
-    }
-}
-
-// MARK: - PrefetchTask
-
-private final class PrefetchTask {
-
-    private let url: URL
-    private let storage: VideoCacheStorage
-    private let segmentCount: Int
-
-    private let lock = NSLock()
-    private var networkTasks: [NetworkTask] = []
-    private var isCancelled = false
-
-    init(url: URL, storage: VideoCacheStorage, segmentCount: Int) {
-        self.url = url
-        self.storage = storage
-        self.segmentCount = segmentCount
-    }
-
-    func start(onComplete: @escaping () -> Void) {
-        fetchManifest(url: url, onComplete: onComplete)
-    }
-
-    func cancel() {
-        lock.lock()
-        isCancelled = true
-        let tasks = networkTasks
-        networkTasks.removeAll()
-        lock.unlock()
-        tasks.forEach { $0.cancel() }
-    }
-
-    // MARK: - Private
-
-    private func fetchManifest(url: URL, onComplete: @escaping () -> Void) {
-        let task = NetworkDownloader.shared.downloadManifest(url: url) { [weak self] data, error in
-            guard let self = self, !self.isCancelled else { onComplete(); return }
-            guard let data = data, let content = String(data: data, encoding: .utf8) else {
-                onComplete(); return
-            }
-            self.storage.save(data: data, for: url.absoluteString)
-            self.processManifest(content: content, baseURL: url, onComplete: onComplete)
-        }
-        addNetworkTask(task)
-    }
-
-    private func processManifest(content: String, baseURL: URL, onComplete: @escaping () -> Void) {
-        if content.contains("#EXT-X-STREAM-INF") {
-            // Master playlist — cache ALL variant manifests so any quality AVPlayer picks is available.
-            let variantURLs = parseAllVariantURLs(content: content, baseURL: baseURL)
-            guard !variantURLs.isEmpty else { onComplete(); return }
-
-            let group = DispatchGroup()
-            for variantURL in variantURLs {
-                guard !isCancelled else { break }
-                group.enter()
-                fetchManifest(url: variantURL, onComplete: { group.leave() })
-            }
-            group.notify(queue: .global(qos: .background)) { onComplete() }
-        } else {
-            // Media playlist — download init segment (if any) + first N segments.
-            var urls: [URL] = []
-            if let initURL = parseInitSegmentURL(content: content, baseURL: baseURL) {
-                urls.append(initURL)
-            }
-            urls.append(contentsOf: parseSegmentURLs(content: content, baseURL: baseURL))
-            downloadSegments(urls: urls, onComplete: onComplete)
-        }
-    }
-
-    private func downloadSegments(urls: [URL], onComplete: @escaping () -> Void) {
-        guard !urls.isEmpty else { onComplete(); return }
-
-        let group = DispatchGroup()
-
-        for url in urls {
-            guard !isCancelled else { break }
-            if storage.exists(for: url.absoluteString) { continue }
-
-            group.enter()
-            let delegate = SegmentAccumulator(storage: storage, url: url) {
-                group.leave()
-            }
-            let task = NetworkDownloader.shared.download(url: url, range: nil, delegate: delegate)
-            addNetworkTask(task)
-        }
-
-        group.notify(queue: .global(qos: .background)) { [weak self] in
-            _ = self // retain until done
-            onComplete()
-        }
-    }
-
-    private func addNetworkTask(_ task: NetworkTask) {
-        lock.lock()
-        networkTasks.append(task)
-        lock.unlock()
-    }
-
-    // MARK: - HLS Parsing
-
-    /// Returns ALL variant/rendition playlist URLs from a master playlist.
-    /// Caching every variant ensures AVPlayer can pick any quality while offline.
-    private func parseAllVariantURLs(content: String, baseURL: URL) -> [URL] {
-        var urls: [URL] = []
-        let lines = content.components(separatedBy: .newlines)
-        var i = 0
-        while i < lines.count {
-            let line = lines[i].trimmingCharacters(in: .whitespaces)
-            if line.hasPrefix("#EXT-X-STREAM-INF") {
-                let nextIndex = i + 1
-                if nextIndex < lines.count {
-                    let urlLine = lines[nextIndex].trimmingCharacters(in: .whitespaces)
-                    if !urlLine.isEmpty, !urlLine.hasPrefix("#"),
-                       let resolved = URL(string: urlLine, relativeTo: baseURL)?.absoluteURL {
-                        urls.append(resolved)
-                    }
-                }
-            }
-            i += 1
-        }
-        return urls
-    }
-
-    /// Parses the `#EXT-X-MAP` init segment URI from a media playlist.
-    /// fMP4 streams require the init segment for every quality level.
-    private func parseInitSegmentURL(content: String, baseURL: URL) -> URL? {
-        for line in content.components(separatedBy: .newlines) {
-            let trimmed = line.trimmingCharacters(in: .whitespaces)
-            guard trimmed.hasPrefix("#EXT-X-MAP:") else { continue }
-            if let uriStart = trimmed.range(of: "URI=\""),
-               let uriEnd = trimmed.range(of: "\"", range: uriStart.upperBound..<trimmed.endIndex) {
-                let uri = String(trimmed[uriStart.upperBound..<uriEnd.lowerBound])
-                return URL(string: uri, relativeTo: baseURL)?.absoluteURL
-            }
-        }
-        return nil
-    }
-
-    /// Parses up to `segmentCount` media segment URLs from a media playlist.
-    private func parseSegmentURLs(content: String, baseURL: URL) -> [URL] {
-        var urls: [URL] = []
-        for line in content.components(separatedBy: .newlines) {
-            guard urls.count < segmentCount else { break }
-            let trimmed = line.trimmingCharacters(in: .whitespaces)
-            guard !trimmed.isEmpty, !trimmed.hasPrefix("#") else { continue }
-            if let resolved = URL(string: trimmed, relativeTo: baseURL)?.absoluteURL {
-                urls.append(resolved)
-            }
-        }
-        return urls
-    }
-}
-
-// MARK: - SegmentAccumulator
-
-/// Accumulates streaming segment data and saves it to cache on completion.
-private final class SegmentAccumulator: NetworkDownloaderDelegate {
-
-    private let storage: VideoCacheStorage
-    private let url: URL
-    private let onComplete: () -> Void
-    private var buffer = Data()
-    private let lock = NSLock()
-
-    init(storage: VideoCacheStorage, url: URL, onComplete: @escaping () -> Void) {
-        self.storage = storage
-        self.url = url
-        self.onComplete = onComplete
-    }
-
-    func didReceiveResponse(task: NetworkTask, response: URLResponse) {}
-
-    func didReceiveData(task: NetworkTask, data: Data) {
-        lock.lock()
-        buffer.append(data)
-        lock.unlock()
-    }
-
-    func didComplete(task: NetworkTask, error: Error?) {
-        if error == nil {
-            lock.lock()
-            let data = buffer
-            lock.unlock()
-            storage.save(data: data, for: url.absoluteString)
-        }
-        onComplete()
-    }
-}