react-native-hls-cache 0.1.0

package/ios/VideoCacheStorage.swift

@@ -0,0 +1,235 @@
+import Foundation
+import CryptoKit
+
+/// Manages the disk persistence layer for video caching.
+///
+/// `VideoCacheStorage` is responsible for handling all filesystem-level
+/// operations related to video caching, including:
+/// - Generating deterministic, filesystem-safe filenames from remote URLs
+/// - Reading and writing cached video data
+/// - Supporting incremental (streaming) writes
+/// - Enforcing a disk size limit using a Least Recently Used (LRU) strategy
+///
+/// This class is designed to be lightweight, deterministic, and resilient to
+/// filesystem errors. All operations are best-effort and never throw, ensuring
+/// that cache failures do not impact video playback.
+internal final class VideoCacheStorage {
+    
+    // MARK: - Properties
+    
+    /// The file manager instance used for all filesystem operations.
+    private let fileManager = FileManager.default
+    
+    /// The maximum allowed size of the cache, in bytes.
+    ///
+    /// When the total size of cached files exceeds this limit, the cache
+    /// is pruned using an LRU (Least Recently Used) strategy.
+    private let maxCacheSize: Int
+    
+    /// The root directory where all cached video files are stored.
+    ///
+    /// This directory is created inside the system Caches directory and
+    /// is guaranteed to exist after initialization.
+    private let cacheDirectory: URL
+    
+    // MARK: - Initialization
+    
+    /// Initializes a new video cache storage manager.
+    ///
+    /// During initialization, the cache directory is created if it does not
+    /// already exist.
+    ///
+    /// - Parameter maxCacheSize: The maximum allowed size of the cache in bytes.
+    init(maxCacheSize: Int) {
+        self.maxCacheSize = maxCacheSize
+        
+        let paths = fileManager.urls(for: .cachesDirectory, in: .userDomainMask)
+        self.cacheDirectory = paths[0].appendingPathComponent("ExpoVideoCache")
+        
+        if !fileManager.fileExists(atPath: cacheDirectory.path) {
+            try? fileManager.createDirectory(
+                at: cacheDirectory,
+                withIntermediateDirectories: true
+            )
+        }
+    }
+    
+    // MARK: - Core API
+    
+    /// Removes all cached files from disk.
+    ///
+    /// This method deletes the entire cache directory and recreates it,
+    /// effectively resetting the cache to an empty state.
+    func clearAll() {
+        try? fileManager.removeItem(at: cacheDirectory)
+        try? fileManager.createDirectory(
+            at: cacheDirectory,
+            withIntermediateDirectories: true
+        )
+    }
+    
+    /// Generates a deterministic, filesystem-safe file URL for a given key.
+    ///
+    /// The provided string is hashed using SHA256 to ensure:
+    /// - Collision resistance
+    /// - Consistent file paths across launches
+    /// - Compatibility with all filesystems
+    ///
+    /// The original file extension (if present) is preserved.
+    ///
+    /// - Parameter urlString: The remote URL or unique cache key.
+    /// - Returns: A local file URL corresponding to the hashed key.
+    func getFilePath(for urlString: String) -> URL {
+        guard let data = urlString.data(using: .utf8) else {
+            return cacheDirectory.appendingPathComponent("unknown.bin")
+        }
+        
+        let hash = SHA256.hash(data: data)
+        let safeFilename = hash.map { String(format: "%02x", $0) }.joined()
+        
+        var extensionName = "bin"
+        if let url = URL(string: urlString) {
+            let ext = url.pathExtension
+            if !ext.isEmpty {
+                extensionName = ext
+            }
+        }
+        
+        return cacheDirectory.appendingPathComponent(
+            "\(safeFilename).\(extensionName)"
+        )
+    }
+    
+    /// Determines whether a valid cached file exists for a given key.
+    ///
+    /// A file is considered valid only if:
+    /// - It exists on disk
+    /// - Its size is greater than zero bytes
+    ///
+    /// - Parameter urlString: The remote URL or unique cache key.
+    /// - Returns: `true` if a valid cached file exists, otherwise `false`.
+    func exists(for urlString: String) -> Bool {
+        let fileUrl = getFilePath(for: urlString)
+        
+        if let attr = try? fileManager.attributesOfItem(
+            atPath: fileUrl.path
+        ),
+           let size = attr[.size] as? Int64,
+           size > 0 {
+            return true
+        }
+        
+        return false
+    }
+    
+    // MARK: - Reading & Writing
+    
+    /// Reads the entire cached file into memory.
+    ///
+    /// This method is intended for small files such as manifests or metadata.
+    ///
+    /// - Parameter urlString: The remote URL or unique cache key.
+    /// - Returns: The cached file data if it exists, otherwise `nil`.
+    func getCachedData(for urlString: String) -> Data? {
+        let fileUrl = getFilePath(for: urlString)
+        return try? Data(contentsOf: fileUrl)
+    }
+    
+    /// Saves data to disk atomically.
+    ///
+    /// The write operation replaces any existing file and guarantees that
+    /// partially written files are never left on disk.
+    ///
+    /// - Parameters:
+    ///   - data: The data to be written to disk.
+    ///   - urlString: The remote URL or unique cache key.
+    func save(data: Data, for urlString: String) {
+        let fileUrl = getFilePath(for: urlString)
+        try? data.write(to: fileUrl, options: .atomic)
+    }
+    
+    /// Deletes the cached file associated with a given key.
+    ///
+    /// This is typically used when a download fails or cached data becomes invalid.
+    ///
+    /// - Parameter urlString: The remote URL or unique cache key.
+    func delete(for urlString: String) {
+        let url = getFilePath(for: urlString)
+        try? fileManager.removeItem(at: url)
+    }
+    
+    // MARK: - Streaming API
+    
+    /// Prepares a file for incremental (streaming) writes.
+    ///
+    /// Any existing file at the target path is deleted to ensure that
+    /// stale or partial data is not mixed with new content.
+    ///
+    /// - Parameter urlString: The remote URL or unique cache key.
+    /// - Returns: A `FileHandle` opened for writing, or `nil` if creation fails.
+    func initializeStreamFile(for urlString: String) -> FileHandle? {
+        let fileUrl = getFilePath(for: urlString)
+        
+        if fileManager.fileExists(atPath: fileUrl.path) {
+            try? fileManager.removeItem(at: fileUrl)
+        }
+        
+        fileManager.createFile(
+            atPath: fileUrl.path,
+            contents: nil
+        )
+        
+        return try? FileHandle(forWritingTo: fileUrl)
+    }
+    
+    // MARK: - Maintenance
+    
+    /// Prunes the cache to enforce the configured size limit.
+    ///
+    /// This method removes the least recently modified files first until
+    /// the total cache size is within the allowed limit.
+    ///
+    /// All failures are silently ignored to ensure that cache maintenance
+    /// never interferes with normal application execution.
+    func prune() {
+        let keys: [URLResourceKey] = [
+            .fileSizeKey,
+            .contentModificationDateKey
+        ]
+        
+        do {
+            let fileUrls = try fileManager.contentsOfDirectory(
+                at: cacheDirectory,
+                includingPropertiesForKeys: keys,
+                options: []
+            )
+            
+            var totalSize = 0
+            var files: [(url: URL, size: Int, date: Date)] = []
+            
+            for url in fileUrls {
+                let values = try url.resourceValues(forKeys: Set(keys))
+                if let size = values.fileSize,
+                   let date = values.contentModificationDate {
+                    totalSize += size
+                    files.append((url, size, date))
+                }
+            }
+            
+            guard totalSize >= maxCacheSize else { return }
+            
+            files.sort { $0.date < $1.date }
+            
+            for file in files {
+                try? fileManager.removeItem(at: file.url)
+                totalSize -= file.size
+                if totalSize < maxCacheSize {
+                    break
+                }
+            }
+            
+        } catch {
+            // Intentionally ignored
+        }
+    }
+}

package/ios/VideoProxyServer.swift

@@ -0,0 +1,185 @@
+import Foundation
+import Network
+
+/// A delegate protocol for managing the lifecycle of child connections.
+protocol ProxyConnectionDelegate: AnyObject {
+    
+    /// Notifies the delegate that a connection handler has completed its work and can be released.
+    ///
+    /// - Parameter id: The unique identifier of the connection handler.
+    func connectionDidClose(id: String)
+}
+
+/// A TCP-based video proxy server built using Apple’s Network framework.
+///
+/// `VideoProxyServer` is responsible for:
+/// - Creating and managing a TCP listener
+/// - Accepting incoming client connections
+/// - Managing the lifecycle of active connection handlers
+/// - Coordinating access to shared state in a thread-safe manner
+///
+/// The server is designed to be idempotent, thread-safe, and resilient to listener failures.
+internal final class VideoProxyServer: ProxyConnectionDelegate {
+    
+    /// The underlying TCP listener.
+    private var listener: NWListener?
+    
+    /// Disk-backed storage used for caching video data.
+    internal let storage: VideoCacheStorage
+    
+    /// The local port on which the server listens for incoming connections.
+    internal let port: Int
+    
+    /// A thread-safe registry of active client connection handlers.
+    private var activeHandlers: [String: ClientConnectionHandler] = [:]
+    
+    /// Internal cached running state used to prevent data races.
+    private var _isRunning: Bool = false
+    
+    /// A mutual exclusion lock used to protect all shared mutable state.
+    private let serverLock = NSLock()
+
+    /// If true, only the first few segments of each video are cached.
+    private let headOnlyCache: Bool
+
+    // Internal constant: How many segments to cache when headOnlyCache is true.
+    private let HEAD_SEGMENT_LIMIT = 3
+    
+    /// Indicates whether the server is currently running.
+    ///
+    /// This property is thread-safe and reflects the authoritative server state.
+    var isRunning: Bool {
+        serverLock.lock()
+        defer { serverLock.unlock() }
+        return _isRunning
+    }
+    
+    /// Creates a new video proxy server.
+    ///
+    /// - Parameters:
+    ///   - port: The local TCP port to bind the listener to.
+    ///   - maxCacheSize: The maximum allowed size of the disk cache, in bytes.
+    ///   - headOnlyCache: If true, only the first few segments of each video are cached.
+    init(port: Int, maxCacheSize: Int, headOnlyCache: Bool = false) {
+        self.port = port
+        self.storage = VideoCacheStorage(maxCacheSize: maxCacheSize)
+        self.headOnlyCache = headOnlyCache
+    }
+    
+    /// Starts the TCP server and begins accepting incoming connections.
+    ///
+    /// This method is thread-safe and prevents duplicate startup attempts.
+    ///
+    /// - Throws: An error if the provided port is invalid or the listener fails to initialize.
+    func start() throws {
+        serverLock.lock()
+        defer { serverLock.unlock() }
+        
+        guard !_isRunning, listener == nil else {
+            return
+        }
+        
+        let parameters = NWParameters.tcp
+        parameters.allowLocalEndpointReuse = true
+        parameters.serviceClass = .responsiveData
+        
+        guard let localPort = NWEndpoint.Port(rawValue: UInt16(port)) else {
+            throw NSError(
+                domain: "VideoProxyServer",
+                code: 500,
+                userInfo: [NSLocalizedDescriptionKey: "Invalid port: \(port)"]
+            )
+        }
+        
+        let listener = try NWListener(using: parameters, on: localPort)
+        
+        listener.stateUpdateHandler = { [weak self] state in
+            guard let self = self else { return }
+            if case .failed = state {
+                DispatchQueue.global().async {
+                    self.stop()
+                }
+            }
+        }
+        
+        listener.newConnectionHandler = { [weak self] connection in
+            self?.handleNewConnection(connection)
+        }
+        
+        listener.start(queue: .global(qos: .userInitiated))
+        self.listener = listener
+        self._isRunning = true
+        
+        DispatchQueue.global(qos: .background).asyncAfter(deadline: .now() + 5.0) { [weak self] in
+            self?.storage.prune()
+        }
+    }
+    
+    /// Stops the server and terminates all active client connections.
+    ///
+    /// This method is fully idempotent and safe to call multiple times.
+    func stop() {
+        serverLock.lock()
+        
+        guard _isRunning || listener != nil else {
+            serverLock.unlock()
+            return
+        }
+        
+        _isRunning = false
+        listener?.cancel()
+        listener = nil
+        
+        let handlersToStop = activeHandlers.values
+        activeHandlers.removeAll()
+        
+        serverLock.unlock()
+        
+        handlersToStop.forEach { $0.stop() }
+    }
+    
+    /// Handles a newly accepted network connection.
+    ///
+    /// - Parameter connection: The incoming TCP connection.
+    private func handleNewConnection(_ connection: NWConnection) {
+        let limit = headOnlyCache ? HEAD_SEGMENT_LIMIT : 0
+
+        let handler = ClientConnectionHandler(
+            connection: connection,
+            storage: storage,
+            port: port,
+            initialSegmentsToCache: limit
+        )
+        
+        handler.delegate = self
+        
+        var shouldStart = false
+        
+        serverLock.lock()
+        if _isRunning {
+            activeHandlers[handler.id] = handler
+            shouldStart = true
+        }
+        serverLock.unlock()
+        
+        if shouldStart {
+            handler.start()
+        } else {
+            connection.cancel()
+        }
+    }
+    
+    /// Removes a completed connection handler from the active registry.
+    ///
+    /// - Parameter id: The unique identifier of the closed connection.
+    func connectionDidClose(id: String) {
+        serverLock.lock()
+        defer { serverLock.unlock() }
+        activeHandlers.removeValue(forKey: id)
+    }
+    
+    /// Clears all cached video data from persistent storage.
+    func clearCache() {
+        storage.clearAll()
+    }
+}

package/lib/module/HlsCache.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=HlsCache.nitro.js.map

package/lib/module/HlsCache.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["HlsCache.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,71 @@
+"use strict";
+
+import { NitroModules } from 'react-native-nitro-modules';
+import { Platform } from 'react-native';
+let _instance = null;
+function getInstance() {
+  if (_instance == null) {
+    _instance = NitroModules.createHybridObject('HlsCache');
+  }
+  return _instance;
+}
+
+/**
+ * Starts the local HLS proxy server.
+ *
+ * @param port - Local port to bind. Defaults to 9000.
+ * @param maxCacheSize - Max disk cache size in bytes. Defaults to 1 GB.
+ * @param headOnlyCache - If true, only caches the first ~3 segments per video (optimised for vertical feeds).
+ */
+export function startServer(port, maxCacheSize, headOnlyCache) {
+  if (Platform.OS !== 'ios') return;
+  getInstance().startServer(port, maxCacheSize, headOnlyCache);
+}
+
+/**
+ * Rewrites a remote URL to route through the local proxy (iOS only).
+ * Returns the original URL unchanged on Android/Web or when the server is not running.
+ *
+ * @param url - Remote HLS URL (e.g. `https://cdn.example.com/video.m3u8`).
+ * @param isCacheable - Set to `false` to bypass the proxy. Defaults to `true`.
+ */
+export function convertUrl(url, isCacheable) {
+  if (Platform.OS !== 'ios') return url;
+  return getInstance().convertUrl(url, isCacheable);
+}
+
+/**
+ * Purges all cached video files from disk.
+ */
+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

@@ -0,0 +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":[]}

package/lib/module/package.json

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

package/lib/typescript/package.json

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

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

@@ -0,0 +1,13 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+export interface HlsCache extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    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

@@ -0,0 +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"}

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

@@ -0,0 +1,36 @@
+/**
+ * Starts the local HLS proxy server.
+ *
+ * @param port - Local port to bind. Defaults to 9000.
+ * @param maxCacheSize - Max disk cache size in bytes. Defaults to 1 GB.
+ * @param headOnlyCache - If true, only caches the first ~3 segments per video (optimised for vertical feeds).
+ */
+export declare function startServer(port?: number, maxCacheSize?: number, headOnlyCache?: boolean): void;
+/**
+ * Rewrites a remote URL to route through the local proxy (iOS only).
+ * Returns the original URL unchanged on Android/Web or when the server is not running.
+ *
+ * @param url - Remote HLS URL (e.g. `https://cdn.example.com/video.m3u8`).
+ * @param isCacheable - Set to `false` to bypass the proxy. Defaults to `true`.
+ */
+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

@@ -0,0 +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"}

package/nitro.json

@@ -0,0 +1,23 @@
+{
+  "cxxNamespace": ["hlscache"],
+  "ios": {
+    "iosModuleName": "HlsCache"
+  },
+  "android": {
+    "androidNamespace": ["hlscache"],
+    "androidCxxLibName": "hlscache"
+  },
+  "autolinking": {
+    "HlsCache": {
+      "ios": {
+        "language": "swift",
+        "implementationClassName": "HybridHlsCache"
+      },
+      "android": {
+        "language": "kotlin",
+        "implementationClassName": "HlsCache"
+      }
+    }
+  },
+  "ignorePaths": ["node_modules"]
+}