ytdlp-react-native 1.0.0

package/android/src/main/java/expo/modules/ytdlp/YtDlpEngine.kt

@@ -0,0 +1,277 @@
+package expo.modules.ytdlp
+
+import android.content.Context
+import com.chaquo.python.Kwarg
+import com.chaquo.python.PyObject
+import com.chaquo.python.Python
+import dev.ffmpegkit_maintained.ytdlp.YtDlp
+import dev.ffmpegkit_maintained.ytdlp.YtDlpException
+import java.io.File
+
+/**
+ * Adapter isolating every call into the third-party `yt-dlp-android` library
+ * and its bundled Chaquopy/Python runtime.
+ *
+ * Only this file talks to `dev.ffmpegkit_maintained.ytdlp` and
+ * `com.chaquo.python`. Everything above relies on this adapter.
+ */
+internal object YtDlpEngine {
+
+  @Volatile
+  private var initialized = false
+
+  /** Starts the embedded Python runtime. Safe to call repeatedly. Not on the main thread. */
+  @Synchronized
+  fun ensureInitialized(context: Context) {
+    if (initialized) return
+    try {
+      YtDlp.init(context.applicationContext)
+      initialized = true
+    } catch (e: YtDlpException) {
+      throw YtDlpNativeException("INIT_FAILED", "Failed to initialize the yt-dlp runtime.", e)
+    } catch (e: Throwable) {
+      throw YtDlpNativeException(
+        "INIT_FAILED",
+        "The yt-dlp runtime is unavailable on this device (its native library may be missing).",
+        e,
+      )
+    }
+  }
+
+  /** Reads the bundled yt-dlp version via Chaquopy. */
+  fun getYtDlpVersion(): String {
+    try {
+      val module = Python.getInstance().getModule("yt_dlp.version")
+      return module.get("__version__").toString()
+    } catch (e: Exception) {
+      throw YtDlpNativeException("VERSION_UNREADABLE", "Failed to read the yt-dlp version.", e)
+    }
+  }
+
+  /**
+   * Extracts media information for [url] without downloading anything and
+   * returns it serialized as JSON (see AGENTS.md §34).
+   *
+   * The bundled `yt_dlp` package is driven directly through Chaquopy because
+   * the wrapper's own `ytdlp_runner` exposes no extraction/output-capture API.
+   */
+  fun extractInfoJson(url: String, options: Map<String, Any?>?): String {
+    validateUrl(url)
+    try {
+      val py = Python.getInstance()
+      val opts = toPyObject(py, extractOptions(options))
+      val ydlClass = py.getModule("yt_dlp").get("YoutubeDL")!!
+      val ydl = ydlClass.call(opts)
+      val info = ydl.callAttr("extract_info", url, Kwarg("download", false))
+      val sanitized = ydl.callAttr("sanitize_info", info)
+      val json = py.getModule("json")
+      return json.callAttr("dumps", sanitized, Kwarg("ensure_ascii", false)).toString()
+    } catch (e: YtDlpNativeException) {
+      throw e
+    } catch (e: Exception) {
+      throw YtDlpNativeException("EXTRACTION_FAILED", "Failed to extract information: ${e.message}", e)
+    }
+  }
+
+  /** Builds the yt-dlp options dict shared by extraction and download. */
+  private fun extractOptions(options: Map<String, Any?>?): MutableMap<String, Any> {
+    val opts = mutableMapOf<String, Any>("skip_download" to true)
+    applyCommonOptions(opts, options)
+    return opts
+  }
+
+  private fun applyCommonOptions(opts: MutableMap<String, Any>, options: Map<String, Any?>?) {
+    if (options == null) return
+    val cookies = options["cookies"] as? Map<*, *>
+    (cookies?.get("path") as? String)?.let { opts["cookiefile"] = it }
+    (options["proxy"] as? String)?.let { opts["proxy"] = it }
+    val headers = mutableMapOf<String, Any>()
+    (options["headers"] as? Map<*, *>)?.forEach { (key, value) ->
+      if (key != null && value != null) headers[key.toString()] = value.toString()
+    }
+    (options["userAgent"] as? String)?.let { headers["User-Agent"] = it }
+    if (headers.isNotEmpty()) opts["http_headers"] = headers
+  }
+
+  /**
+   * Runs the download for [task]. Drives yt-dlp directly through Chaquopy so
+   * that our own progress hook can abort natively on cancellation (see
+   * AGENTS.md §22 and [YtDlpTask]).
+   *
+   * Throws a classified [YtDlpNativeException] on failure.
+   */
+  fun executeDownload(task: YtDlpTask, options: Map<String, Any?>, outputDirectory: File) {
+    val url = (options["url"] as? String)?.trim().takeIf { !it.isNullOrBlank() }
+      ?: throw YtDlpNativeException("INVALID_URL", "URL is required.")
+    try {
+      rejectUnsupportedFeatures(options)
+      val py = Python.getInstance()
+      val opts = buildDownloadOptions(options, outputDirectory)
+      downloaderFunction(py).callAttr("execute", task, url, toPyObject(py, opts))
+    } catch (e: YtDlpNativeException) {
+      throw e
+    } catch (e: com.chaquo.python.PyException) {
+      val message = e.message ?: ""
+      if (task.isCancelRequested() || message.contains(CANCEL_SENTINEL)) {
+        throw YtDlpNativeException("CANCELLED", "Download cancelled.")
+      }
+      throw YtDlpNativeException(classifyDownloadFailure(message), message, e)
+    } catch (e: Exception) {
+      throw YtDlpNativeException("DOWNLOAD_FAILED", "Download failed: ${e.message}", e)
+    }
+  }
+
+  private fun buildDownloadOptions(options: Map<String, Any?>, outputDirectory: File): MutableMap<String, Any> {
+    val opts = mutableMapOf<String, Any>()
+    (options["format"] as? String)?.takeIf { it.isNotBlank() }?.let { opts["format"] = it }
+    val filename = (options["output"] as? Map<*, *>)?.get("filename") as? String
+    val sanitizedTemplate = YtDlpFileUtil.sanitizeFilenameTemplate(filename ?: YtDlpFileUtil.DEFAULT_FILENAME)
+    opts["outtmpl"] = File(outputDirectory, sanitizedTemplate).absolutePath
+    opts["quiet"] = true
+
+    applyCommonOptions(opts, options)
+
+    (options["referer"] as? String)?.takeIf { it.isNotBlank() }?.let { opts["http_referer"] = it }
+
+    val playlist = options["playlist"] as? Map<*, *>
+    if (playlist?.get("enabled") != true) opts["noplaylist"] = true
+    (playlist?.get("start") as? Number)?.takeIf { it.toInt() > 0 }?.let { opts["playliststart"] = it.toInt() }
+    (playlist?.get("end") as? Number)?.takeIf { it.toInt() > 0 }?.let { opts["playlistend"] = it.toInt() }
+
+    val subtitles = options["subtitles"] as? Map<*, *>
+    if (subtitles?.get("enabled") == true) {
+      opts["writesubtitles"] = true
+      (subtitles["languages"] as? List<*>)?.mapNotNull { it as? String }?.takeIf { it.isNotEmpty() }
+        ?.let { opts["subtitleslangs"] = it }
+      if (subtitles["autoGenerated"] == true) opts["writeautomaticsub"] = true
+    }
+
+    val network = options["network"] as? Map<*, *>
+    (network?.get("timeout") as? Number)?.takeIf { it.toInt() > 0 }?.let { opts["socket_timeout"] = it.toInt() }
+    (network?.get("retries") as? Number)?.takeIf { it.toInt() >= 0 }?.let { opts["retries"] = it.toInt() }
+
+    return opts
+  }
+
+  /** Anything we cannot honestly support is rejected up front (AGENTS.md §19). */
+  private fun rejectUnsupportedFeatures(options: Map<String, Any?>) {
+    if (options["merge"] == true) {
+      throw YtDlpNativeException(
+        "PROCESSING_FAILED",
+        "Merging video and audio requires FFmpeg, which is not bundled with yt-dlp-android.",
+      )
+    }
+    val audio = options["audio"] as? Map<*, *>
+    if (audio?.get("only") == true || audio?.get("format") != null || audio?.get("quality") != null) {
+      throw YtDlpNativeException(
+        "PROCESSING_FAILED",
+        "Audio extraction and re-encoding require FFmpeg, which is not bundled with yt-dlp-android.",
+      )
+    }
+    if (options["metadata"] != null || options["thumbnail"] != null) {
+      throw YtDlpNativeException(
+        "PROCESSING_FAILED",
+        "Metadata and thumbnail embedding are not supported in this version.",
+      )
+    }
+  }
+
+  private fun classifyDownloadFailure(message: String): String {
+    val haystack = message.lowercase()
+    return when {
+      haystack.contains("youtube") && haystack.contains("sign in to confirm") -> "AUTHENTICATION_REQUIRED"
+      haystack.contains("login required") || haystack.contains("log in") || haystack.contains("sign up") ->
+        "AUTHENTICATION_REQUIRED"
+      haystack.contains("private") || haystack.contains("members-only") -> "PRIVATE_CONTENT"
+      haystack.contains("age-") || haystack.contains("age restricted") || haystack.contains("mature") ->
+        "AGE_RESTRICTED"
+      haystack.contains("geo") || haystack.contains("not available in your country") -> "GEO_RESTRICTED"
+      haystack.contains("ffmpeg") || haystack.contains("postprocess") || haystack.contains("merge") ->
+        "PROCESSING_FAILED"
+      haystack.contains("requested format") || haystack.contains("no video formats") ||
+        haystack.contains("format combination") -> "FORMAT_UNAVAILABLE"
+      haystack.contains("http error") || haystack.contains("connection") || haystack.contains("timed out") ||
+        haystack.contains("timeout") || haystack.contains("unreachable") || haystack.contains("reset by peer") ||
+        haystack.contains("couldn't connect") || haystack.contains("503") || haystack.contains("429") ->
+        "NETWORK_ERROR"
+      else -> "DOWNLOAD_FAILED"
+    }
+  }
+
+  /** Lazily execs (once) the Python helper used to run downloads. */
+  private fun downloaderFunction(py: Python): PyObject {
+    return downloaderStore.getOrPut(py) {
+      val builtins = py.getBuiltins()
+      val ns = builtins.callAttr("dict")
+      builtins.callAttr("exec", DOWNLOAD_HELPER_SCRIPT, ns, ns)
+      // `ns` is a dict, so `execute` is an *item*, not an attribute: `PyObject.get`
+      // (attribute access) would return null. Use the container view instead.
+      ns.asMap()[PyObject.fromJava("execute")]
+        ?: throw YtDlpNativeException("INIT_FAILED", "The download helper is unavailable.")
+    }
+  }
+
+  private fun validateUrl(url: String?) {
+    if (url.isNullOrBlank()) {
+      throw YtDlpNativeException("INVALID_URL", "URL is required.")
+    }
+  }
+
+  /**
+   * Converts a Kotlin value into a genuine Python object. Chaquopy does not
+   * automatically convert Java Maps/Lists into Python containers (see
+   * chaquo/chaquopy#1048), so they would otherwise reach yt-dlp as opaque
+   * `java.util.LinkedHashMap` proxies and break `dict.get(key, default)` calls.
+   */
+  private fun toPyObject(py: Python, value: Any?): PyObject {
+    return when (value) {
+      null -> PyObject.fromJava(null)
+      is PyObject -> value
+      is Map<*, *> -> {
+        val d = py.getBuiltins().callAttr("dict")
+        val view = d.asMap()
+        value.forEach { (key, v) ->
+          if (key != null && v != null) {
+            view.put(PyObject.fromJava(key.toString()), toPyObject(py, v))
+          }
+        }
+        d
+      }
+      is List<*> -> {
+        val l = py.getBuiltins().callAttr("list")
+        val view = l.asList()
+        value.filterNotNull().forEach { view.add(toPyObject(py, it)) }
+        l
+      }
+      else -> PyObject.fromJava(value)
+    }
+  }
+
+private const val CANCEL_SENTINEL = "YTDLP_CANCELLED"
+
+  /**
+   * Drive the bundled yt-dlp directly. Importing is deferred so our first
+   * call stays fast. `execute` returns the download retcode (0 = success);
+   * raising from the progress hook aborts yt-dlp natively on cancellation.
+   */
+  private val DOWNLOAD_HELPER_SCRIPT = """
+    def _expo_ytdlp_hook(task, d):
+        if task.isCancelRequested():
+            raise RuntimeError("YTDLP_CANCELLED")
+        downloaded = int(d.get('downloaded_bytes') or 0)
+        total = int(d.get('total_bytes') or d.get('total_bytes_estimate') or 0)
+        speed = int(d.get('speed') or 0)
+        eta = int(d.get('eta') or 0)
+        filename = str(d.get('filename') or '')
+        task.onPythonProgress(downloaded, total, speed, eta, filename)
+
+    def execute(task, url, opts):
+        import yt_dlp
+        opts = dict(opts)
+        opts['progress_hooks'] = [lambda d, t=task: _expo_ytdlp_hook(t, d)]
+        with yt_dlp.YoutubeDL(opts) as ydl:
+            return ydl.download([url])
+  """.trimIndent()
+
+  private val downloaderStore = java.util.concurrent.ConcurrentHashMap<Python, PyObject>()
+}

package/android/src/main/java/expo/modules/ytdlp/YtDlpException.kt

@@ -0,0 +1,14 @@
+package expo.modules.ytdlp
+
+/**
+ * Internal exception carrying a public error code.
+ *
+ * The code is embedded in a prefixed [message] so that it survives the
+ * Expo Modules bridge, which only guarantees `message` (and a generic
+ * `code`) to JavaScript. The TypeScript layer parses the prefix.
+ */
+internal class YtDlpNativeException(
+  val errorCode: String,
+  userMessage: String,
+  cause: Throwable? = null,
+) : Exception("YTD_NATIVE|$errorCode|$userMessage", cause)

package/android/src/main/java/expo/modules/ytdlp/YtDlpFileUtil.kt

@@ -0,0 +1,89 @@
+package expo.modules.ytdlp
+
+import java.io.File
+
+/**
+ * Safe handling of the yt-dlp output location.
+ *
+ * All output lives inside app-specific storage (see AGENTS.md §24). User
+ * strings are treated as untrusted input: no path traversal, no illegal
+ * characters, no absurd lengths (see AGENTS.md §25, §26).
+ */
+internal object YtDlpFileUtil {
+
+  const val DEFAULT_DIRECTORY = "Downloads"
+  const val DEFAULT_FILENAME = "%(title)s.%(ext)s"
+
+  /** Single-segment directory name; separators and `..` are removed. */
+  fun sanitizeDirectorySegment(name: String): String {
+    val cleaned = name
+      .replace(Regex("[\\\\/]"), "_")
+      .replace(Regex("[\\p{Cntrl}]"), "")
+      .replace("..", "_")
+      .replace(Regex("^[.\\s]+"), "")
+      .take(64)
+    return cleaned.ifBlank { DEFAULT_DIRECTORY }
+  }
+
+  /**
+   * Sanitizes a yt-dlp output template. `%(...)s` directives are preserved,
+   * every other character is scrubbed to stay safe on the filesystem.
+   */
+  fun sanitizeFilenameTemplate(template: String): String {
+    if (template.isBlank()) return DEFAULT_FILENAME
+    val directive = Regex("%\\([^)]*\\)s")
+    val out = StringBuilder()
+    var index = 0
+    for (match in directive.findAll(template)) {
+      out.append(sanitizeStatic(template.substring(index, match.range.first)))
+      out.append(match.value)
+      index = match.range.last + 1
+    }
+    out.append(sanitizeStatic(template.substring(index)))
+    return out.toString().ifBlank { DEFAULT_FILENAME }
+  }
+
+  fun resolveOutputDirectory(baseDir: File, requested: String?): File {
+    val name = requested?.takeIf { it.isNotBlank() } ?: DEFAULT_DIRECTORY
+    val dir = File(baseDir, sanitizeDirectorySegment(name))
+    if (!dir.exists() && !dir.mkdirs()) {
+      throw YtDlpNativeException("STORAGE_ERROR", "Could not create output directory.")
+    }
+    if (!dir.isDirectory) {
+      throw YtDlpNativeException("STORAGE_ERROR", "Output path is not a directory.")
+    }
+    return dir
+  }
+
+  /** Returns the newest file created under [baseDir] after [createdAfter]. */
+  fun findNewestFile(baseDir: File, createdAfter: Long): File? {
+    if (!baseDir.exists()) return null
+    return baseDir
+      .walkTopDown()
+      .filter { it.isFile && it.lastModified() >= createdAfter - GRACE_MS }
+      .maxByOrNull { it.lastModified() }
+  }
+
+  /** Moves a file back inside [baseDir] if it escaped (path traversal defense). */
+  fun ensureContained(file: File, baseDir: File): File {
+    val base = baseDir.canonicalFile
+    val fileCanonical = file.canonicalFile
+    if (fileCanonical.path == base.path || fileCanonical.path.startsWith(base.path + File.separator)) {
+      return file
+    }
+    val target = File(baseDir, file.name)
+    if (file.renameTo(target)) {
+      return target
+    }
+    throw YtDlpNativeException("STORAGE_ERROR", "Downloaded file could not be secured in the output directory.")
+  }
+
+  private fun sanitizeStatic(part: String): String {
+    return part
+      .replace(Regex("[\\\\/:*?\"<>|\\p{Cntrl}]"), "_")
+      .replace("..", "_")
+      .take(240)
+  }
+
+  private const val GRACE_MS = 60_000L
+}

package/android/src/main/java/expo/modules/ytdlp/YtDlpTask.kt

@@ -0,0 +1,225 @@
+package expo.modules.ytdlp
+
+import java.io.File
+import java.util.UUID
+import java.util.concurrent.atomic.AtomicBoolean
+import java.util.concurrent.atomic.AtomicLong
+
+internal enum class YtDlpStatus {
+  QUEUED,
+  EXTRACTING,
+  DOWNLOADING,
+  PROCESSING,
+  COMPLETED,
+  CANCELLED,
+  FAILED,
+}
+
+/**
+ * A single download unit.
+ *
+ * Downloads are driven directly through Chaquopy (not the wrapper's runner),
+ * because the wrapper's Python runner wraps its progress hook in
+ * `try/except Exception` and swallows any exception we throw from Java — that
+ * would make cancellation impossible (see AGENTS.md §22). Instead our own
+ * Python hook calls back into Java through [onPythonProgress] and checks
+ * [isCancelRequested]; when cancellation is requested, the hook raises
+ * `RuntimeError("YTDLP_CANCELLED")` inside yt-dlp, aborting it natively.
+ */
+internal class YtDlpTask(
+  val id: String = UUID.randomUUID().toString(),
+  val outputDirectory: File,
+  private val onEvent: (Map<String, Any>) -> Unit,
+) {
+
+  @Volatile
+  var status: YtDlpStatus = YtDlpStatus.QUEUED
+    private set
+
+  @Volatile
+  var errorCode: String? = null
+
+  @Volatile
+  var errorMessage: String? = null
+
+  @Volatile
+  var startTime: Long = System.currentTimeMillis()
+
+  private val cancelRequested = AtomicBoolean(false)
+  internal val snapshot = ProgressSnapshot()
+  private val lastEmit = AtomicLong(0L)
+
+  fun isCancelRequested(): Boolean = cancelRequested.get()
+
+  fun requestCancel(): Boolean = cancelRequested.compareAndSet(false, true)
+
+  @Synchronized
+  fun setStatus(newStatus: YtDlpStatus) {
+    if (status == YtDlpStatus.COMPLETED || status == YtDlpStatus.CANCELLED || status == YtDlpStatus.FAILED) return
+    status = newStatus
+  }
+
+  /**
+   * Called from Python (via the Chaquopy bridge) on every progress tick.
+   * Structured numbers come straight from yt-dlp's progress hook dict.
+   */
+  fun onPythonProgress(
+    downloadedBytes: Long,
+    totalBytes: Long,
+    speedBytesPerSecond: Long,
+    etaSeconds: Long,
+    filename: String,
+  ) {
+    if (cancelRequested.get()) return
+    snapshot.update(downloadedBytes, totalBytes, speedBytesPerSecond, etaSeconds, filename)
+    when {
+      status == YtDlpStatus.QUEUED -> setStatus(YtDlpStatus.EXTRACTING)
+      status == YtDlpStatus.EXTRACTING && (snapshot.downloadedBytes ?: 0L) > 0L ->
+        setStatus(YtDlpStatus.DOWNLOADING)
+    }
+    emitProgress()
+  }
+
+  fun emitState() {
+    onEvent(statePayload())
+  }
+
+  fun emitCompleted(resultFile: File?) {
+    setStatus(YtDlpStatus.COMPLETED)
+    onEvent(completedPayload(resultFile))
+  }
+
+  fun emitCancelled() {
+    setStatus(YtDlpStatus.CANCELLED)
+    onEvent(cancelledPayload())
+  }
+
+  fun emitError(code: String, message: String) {
+    errorCode = code
+    errorMessage = message
+    setStatus(YtDlpStatus.FAILED)
+    onEvent(errorPayload())
+  }
+
+  private fun emitProgress() {
+    val now = System.nanoTime()
+    if (now - lastEmit.get() >= THROTTLE_NANOS) {
+      lastEmit.set(now)
+      onEvent(progressPayload())
+    }
+  }
+
+  private fun phaseOf(): String = when (status) {
+    YtDlpStatus.QUEUED, YtDlpStatus.EXTRACTING -> "extracting"
+    YtDlpStatus.DOWNLOADING -> "downloading"
+    YtDlpStatus.PROCESSING, YtDlpStatus.COMPLETED -> "processing"
+    YtDlpStatus.CANCELLED, YtDlpStatus.FAILED -> "downloading"
+  }
+
+  private fun progressPayload(): Map<String, Any> = mapOf(
+    "type" to "progress",
+    "taskId" to id,
+    "status" to status.name.lowercase(),
+    "phase" to phaseOf(),
+    "progress" to mapOf(
+      "percent" to snapshot.percent,
+      "downloadedBytes" to snapshot.downloadedBytes,
+      "totalBytes" to snapshot.totalBytes,
+      "speedBytesPerSecond" to snapshot.speedBytesPerSecond,
+      "etaSeconds" to snapshot.etaSeconds,
+      "filename" to snapshot.filename,
+    ),
+  )
+
+  private fun statePayload(): Map<String, Any> = mapOf(
+    "type" to "state",
+    "taskId" to id,
+    "status" to status.name.lowercase(),
+    "phase" to phaseOf(),
+  )
+
+  private fun completedPayload(resultFile: File?): Map<String, Any> {
+    val size = resultFile?.length() ?: 0L
+    return mapOf(
+      "type" to "completed",
+      "taskId" to id,
+      "status" to "completed",
+      "phase" to "processing",
+      "result" to mapOf(
+        "taskId" to id,
+        "path" to (resultFile?.absolutePath ?: null),
+        "uri" to null,
+        "filename" to (resultFile?.name ?: null),
+        "mimeType" to null,
+        "size" to (if (size > 0) size else null),
+        "duration" to null,
+      ),
+    )
+  }
+
+  private fun errorPayload(): Map<String, Any> = mapOf(
+    "type" to "error",
+    "taskId" to id,
+    "status" to "failed",
+    "phase" to phaseOf(),
+    "error" to mapOf(
+      "code" to (errorCode ?: "DOWNLOAD_FAILED"),
+      "message" to (errorMessage ?: "Download failed"),
+    ),
+  )
+
+  private fun cancelledPayload(): Map<String, Any> = mapOf(
+    "type" to "cancelled",
+    "taskId" to id,
+    "status" to "cancelled",
+    "phase" to "downloading",
+  )
+
+  private companion object {
+    const val THROTTLE_NANOS = 200_000_000L // 200 ms, see AGENTS.md §40
+  }
+}
+
+/** Rolling view of the latest structured download progress numbers. */
+internal class ProgressSnapshot {
+  @Volatile
+  var percent: Double? = null
+    private set
+
+  @Volatile
+  var downloadedBytes: Long? = null
+    private set
+
+  @Volatile
+  var totalBytes: Long? = null
+    private set
+
+  @Volatile
+  var speedBytesPerSecond: Long? = null
+    private set
+
+  @Volatile
+  var etaSeconds: Long? = null
+    private set
+
+  @Volatile
+  var filename: String? = null
+    private set
+
+  fun update(
+    downloaded: Long,
+    total: Long,
+    speed: Long,
+    eta: Long,
+    name: String,
+  ) {
+    if (downloaded > 0L) downloadedBytes = downloaded
+    if (total > 0L) {
+      totalBytes = total
+      percent = downloaded.coerceAtMost(total) * 100.0 / total
+    }
+    if (speed > 0L) speedBytesPerSecond = speed
+    if (eta >= 0L) etaSeconds = eta
+    if (name.isNotBlank()) filename = name
+  }
+}

package/build/ExpoYtDlpModule.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Thin typed binding to the native `ExpoYtDlp` module.
+ *
+ * On unsupported platforms (web/iOS) the native module is absent; we detect
+ * this here and surface it at call time as `UNSUPPORTED_PLATFORM`, so a plain
+ * import never crashes.
+ */
+import { NativeModule } from 'expo';
+import type { DownloadEvent, DownloadStatus } from './types';
+export interface DownloadTaskInfo {
+    taskId: string;
+    directory: string;
+}
+export interface DownloadStatusInfo {
+    taskId: string;
+    status: DownloadStatus;
+    percent?: number;
+    downloadedBytes?: number;
+    totalBytes?: number;
+    speedBytesPerSecond?: number;
+    etaSeconds?: number;
+    filename?: string;
+}
+export type ExpoYtDlpModuleEvents = {
+    downloadEvent: (event: DownloadEvent) => void;
+};
+export declare class ExpoYtDlpNativeModule extends NativeModule<ExpoYtDlpModuleEvents> {
+    getVersion(): Promise<string>;
+    extractInfo(url: string, options: Record<string, unknown>): Promise<string>;
+    startDownload(options: Record<string, unknown>): Promise<DownloadTaskInfo>;
+    cancelDownload(taskId: string): Promise<boolean>;
+    getDownloadStatus(taskId: string): Promise<DownloadStatusInfo | null>;
+}
+export declare const NativeExpoYtDlp: ExpoYtDlpNativeModule | null;
+//# sourceMappingURL=ExpoYtDlpModule.d.ts.map

package/build/ExpoYtDlpModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoYtDlpModule.d.ts","sourceRoot":"","sources":["../src/ExpoYtDlpModule.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,YAAY,EAA+B,MAAM,MAAM,CAAC;AAEjE,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE7D,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,cAAc,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,aAAa,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;CAC/C,CAAC;AAEF,MAAM,CAAC,OAAO,OAAO,qBAAsB,SAAQ,YAAY,CAAC,qBAAqB,CAAC;IACpF,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAC7B,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAC3E,aAAa,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAC1E,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAChD,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;CACtE;AAED,eAAO,MAAM,eAAe,EAAE,qBAAqB,GAAG,IACW,CAAC"}

package/build/ExpoYtDlpModule.js

@@ -0,0 +1,10 @@
+/**
+ * Thin typed binding to the native `ExpoYtDlp` module.
+ *
+ * On unsupported platforms (web/iOS) the native module is absent; we detect
+ * this here and surface it at call time as `UNSUPPORTED_PLATFORM`, so a plain
+ * import never crashes.
+ */
+import { requireOptionalNativeModule } from 'expo';
+export const NativeExpoYtDlp = requireOptionalNativeModule('ExpoYtDlp');
+//# sourceMappingURL=ExpoYtDlpModule.js.map

package/build/ExpoYtDlpModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoYtDlpModule.js","sourceRoot":"","sources":["../src/ExpoYtDlpModule.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAgB,2BAA2B,EAAE,MAAM,MAAM,CAAC;AAgCjE,MAAM,CAAC,MAAM,eAAe,GAC1B,2BAA2B,CAAwB,WAAW,CAAC,CAAC","sourcesContent":["/**\n * Thin typed binding to the native `ExpoYtDlp` module.\n *\n * On unsupported platforms (web/iOS) the native module is absent; we detect\n * this here and surface it at call time as `UNSUPPORTED_PLATFORM`, so a plain\n * import never crashes.\n */\nimport { NativeModule, requireOptionalNativeModule } from 'expo';\n\nimport type { DownloadEvent, DownloadStatus } from './types';\n\nexport interface DownloadTaskInfo {\n  taskId: string;\n  directory: string;\n}\n\nexport interface DownloadStatusInfo {\n  taskId: string;\n  status: DownloadStatus;\n  percent?: number;\n  downloadedBytes?: number;\n  totalBytes?: number;\n  speedBytesPerSecond?: number;\n  etaSeconds?: number;\n  filename?: string;\n}\n\nexport type ExpoYtDlpModuleEvents = {\n  downloadEvent: (event: DownloadEvent) => void;\n};\n\nexport declare class ExpoYtDlpNativeModule extends NativeModule<ExpoYtDlpModuleEvents> {\n  getVersion(): Promise<string>;\n  extractInfo(url: string, options: Record<string, unknown>): Promise<string>;\n  startDownload(options: Record<string, unknown>): Promise<DownloadTaskInfo>;\n  cancelDownload(taskId: string): Promise<boolean>;\n  getDownloadStatus(taskId: string): Promise<DownloadStatusInfo | null>;\n}\n\nexport const NativeExpoYtDlp: ExpoYtDlpNativeModule | null =\n  requireOptionalNativeModule<ExpoYtDlpNativeModule>('ExpoYtDlp');\n"]}

package/build/ExpoYtDlpModule.web.d.ts

@@ -0,0 +1,11 @@
+import { NativeModule } from 'expo';
+/**
+ * Web placeholder. The package is Android-only (see AGENTS.md §3); every
+ * method throws a meaningful error instead of a silent no-op.
+ */
+declare class ExpoYtDlpModule extends NativeModule {
+    getVersion(): Promise<string>;
+}
+declare const _default: typeof ExpoYtDlpModule;
+export default _default;
+//# sourceMappingURL=ExpoYtDlpModule.web.d.ts.map

package/build/ExpoYtDlpModule.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoYtDlpModule.web.d.ts","sourceRoot":"","sources":["../src/ExpoYtDlpModule.web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAqB,MAAM,MAAM,CAAC;AAIvD;;;GAGG;AACH,cAAM,eAAgB,SAAQ,YAAY;IACxC,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;CAG9B;;AAED,wBAA+D"}