Fix: Add binary compatibility forwarders for recover* methods

In 18.0.0-M3, recover/recoverToTry/recoverToEither/recoverIgnoreErrors
were moved from EventStream/Signal to RecoverOps[Self, A] where Self
has no `<: Observable[_]` bound. This changed the Scala.js IR method
descriptors, breaking linking for libraries compiled against 17.x.

Add forwarding overrides on EventStream, Signal, and StrictSignal that
delegate to mapRecover, restoring the old method descriptors.

Fixes #149

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: nguyenyou

src/main/scala/com/raquo/airstream/core/EventStream.scala

@@ -21,7 +21,7 @@ import java.util.concurrent.Flow
 import scala.concurrent.{ExecutionContext, Future}
 import scala.scalajs.js
 import scala.scalajs.js.JSConverters._
-import scala.util.{Success, Try}
+import scala.util.{Failure, Success, Try}
 
 trait EventStream[+A]
 extends Observable[A]
@@ -39,6 +39,20 @@ with DynamicImportStreamOps[A] // dynamicImport (Scala 3 only)
     new MapStream(this, project, recover = None)
   }
 
+  // -- BinCompat forwarders for RecoverOps methods.
+  //  In Airstream 17.x, these were defined on EventStream directly. In 18.0.0-M3
+  //  they moved to RecoverOps[Self, A] where Self has no `<: Observable[_]` bound,
+  //  changing the Scala.js IR method descriptor. These forwarders restore the old
+  //  descriptors so that libraries compiled against 17.x can link against 18.x.
+
+  override def recover[B >: A](pf: PartialFunction[Throwable, Option[B]]): EventStream[B] = mapRecover(identity, pf)
+
+  override def recoverIgnoreErrors: EventStream[A] = recover[A](_ => None)
+
+  override def recoverToTry: EventStream[Try[A]] = mapRecover(Success(_), err => Some(Failure(err)))
+
+  override def recoverToEither: EventStream[Either[Throwable, A]] = mapRecover(Right(_), err => Some(Left(err)))
+
   /** If `recover` is defined and needs to be called, it can do the following:
     *  - Return Some(value) to make this stream emit value
     *  - Return None to make this stream ignore (swallow) this error

src/main/scala/com/raquo/airstream/core/Signal.scala

@@ -18,7 +18,7 @@ import com.raquo.ew.JsArray
 import scala.concurrent.{ExecutionContext, Future}
 import scala.scalajs.js
 import scala.scalajs.js.JSConverters._
-import scala.util.Try
+import scala.util.{Failure, Success, Try}
 
 /** Signal is an Observable with a current value. */
 trait Signal[+A]
@@ -52,6 +52,16 @@ with DynamicImportSignalOps[A] // dynamicImport (Scala 3 only)
     new MapSignal(parent = this, project, recover = None)
   }
 
+  // -- BinCompat forwarders for RecoverOps methods (see EventStream for explanation)
+
+  override def recover[B >: A](pf: PartialFunction[Throwable, Option[B]]): Signal[B] = mapRecover(identity, pf)
+
+  override def recoverIgnoreErrors: Signal[A] = recover[A](_ => None)
+
+  override def recoverToTry: Signal[Try[A]] = mapRecover(Success(_), err => Some(Failure(err)))
+
+  override def recoverToEither: Signal[Either[Throwable, A]] = mapRecover(Right(_), err => Some(Left(err)))
+
   /** If `recover` is defined and needs to be called, it can do the following:
     *  - Return Some(value) to make this stream emit value
     *  - Return None to make this stream ignore (swallow) this error

src/main/scala/com/raquo/airstream/state/StrictSignal.scala

@@ -4,7 +4,7 @@ import com.raquo.airstream.core.{CoreOps, RecoverOps, ScanLeftSignalOps, Signal}
 import com.raquo.airstream.debug.{Debugger, DebugSignalOps}
 import com.raquo.airstream.distinct.DistinctOps
 
-import scala.util.Try
+import scala.util.{Failure, Success, Try}
 
 /** A Signal that lets you directly query its current value.
   *
@@ -32,6 +32,16 @@ with DebugSignalOps[StrictSignal, A] {
     )
   }
 
+  // -- BinCompat forwarders: must override Signal's forwarders with StrictSignal return type
+
+  override def recover[B >: A](pf: PartialFunction[Throwable, Option[B]]): StrictSignal[B] = mapRecover(identity, pf)
+
+  override def recoverIgnoreErrors: StrictSignal[A] = recover[A](_ => None)
+
+  override def recoverToTry: StrictSignal[Try[A]] = mapRecover(Success(_), err => Some(Failure(err)))
+
+  override def recoverToEither: StrictSignal[Either[Throwable, A]] = mapRecover(Right(_), err => Some(Left(err)))
+
   /** If `recover` is defined and needs to be called, it can do the following:
     *  - Return Some(value) to make this stream emit value
     *  - Return None to make this signal ignore (swallow) this error