add MutationObserver

dom/src/main/scala/fs2/dom/MutationObserver.scala

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2022 Arman Bilge
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package fs2.dom
+
+import cats.syntax.all._
+import org.scalajs.dom
+import cats.effect.kernel.Async
+import cats.effect.std.Dispatcher
+import cats.effect.kernel.Resource
+import cats.effect.kernel.Sync
+
+abstract class MutationObserver[F[_]] private[dom] {
+
+  def observe(target: Node[F], options: dom.MutationObserverInit): F[Unit]
+
+  def disconnect: F[Unit]
+
+  def takeRecords: F[List[MutationRecord[F]]]
+
+}
+
+object MutationObserver {
+
+  def apply[F[_]](
+      callback: (List[dom.MutationRecord], MutationObserver[F]) => F[Unit]
+  )(implicit F: Async[F]): Resource[F, MutationObserver[F]] = for {
+    dispatcher <- Dispatcher.parallel[F]
+    jsObserver <- Resource.make(
+      F.delay(
+        new dom.MutationObserver((a, b) =>
+          dispatcher.unsafeRunAndForget(callback(a.toList, fromJS(b)))
+        )
+      )
+    )(obs => F.delay(obs.disconnect()))
+  } yield fromJS(jsObserver)
+
+  private def fromJS[F[_]](
+      jsObserver: dom.MutationObserver
+  )(implicit F: Sync[F]): MutationObserver[F] =
+    new MutationObserver[F] {
+
+      def observe(target: Node[F], options: dom.MutationObserverInit): F[Unit] =
+        F.delay(jsObserver.observe(target.asInstanceOf[dom.Node], options))
+
+      def disconnect: F[Unit] = F.delay(jsObserver.disconnect())
+
+      def takeRecords: F[List[MutationRecord[F]]] =
+        F.delay(jsObserver.takeRecords()).map(_.toList.map(MutationRecord.fromJS))
+
+    }
+
+}

dom/src/main/scala/fs2/dom/MutationRecord.scala

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2022 Arman Bilge
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package fs2.dom
+
+import org.scalajs.dom
+
+abstract class MutationRecord[F[_]] private[dom] {
+
+  def `type`: String
+
+  def target: Node[F]
+
+  def addedNodes: List[Node[F]]
+
+  def removedNodes: List[Node[F]]
+
+  def previousSibling: Option[Node[F]]
+
+  def nextSibling: Option[Node[F]]
+
+  def attributeName: Option[String]
+
+  def attributeNamespace: Option[String]
+
+  def oldValue: Option[String]
+
+}
+
+object MutationRecord {
+
+  private[dom] def fromJS[F[_]](record: dom.MutationRecord) = new MutationRecord[F] {
+
+    override def `type`: String = record.`type`
+
+    override def target: Node[F] = record.target.asInstanceOf[Node[F]]
+
+    override def addedNodes: List[Node[F]] =
+      record.addedNodes.toList.asInstanceOf[List[Node[F]]]
+
+    override def removedNodes: List[Node[F]] =
+      record.removedNodes.toList.asInstanceOf[List[Node[F]]]
+
+    override def previousSibling: Option[Node[F]] = Option(
+      record.previousSibling.asInstanceOf[Node[F]]
+    )
+
+    override def nextSibling: Option[Node[F]] =
+      Option(record.nextSibling.asInstanceOf[Node[F]])
+
+    override def attributeName: Option[String] =
+      Option(record.attributeName)
+
+    override def attributeNamespace: Option[String] =
+      Option(record.attributeNamespace)
+
+    override def oldValue: Option[String] = Option(record.oldValue)
+
+  }
+
+}

dom/src/main/scala/fs2/dom/ResizeObserver.scala

@@ -22,7 +22,7 @@ import cats.effect.std.Dispatcher
 import cats.effect.kernel.Resource
 import cats.effect.kernel.Sync
 
-abstract class ResizeObserver[F[_]] private {
+abstract class ResizeObserver[F[_]] private[dom] {
 
   def observe(target: Element[F]): F[Unit]
 
@@ -37,19 +37,21 @@ abstract class ResizeObserver[F[_]] private {
 object ResizeObserver {
 
   def apply[F[_]](
-      callback: (List[dom.ResizeObserverEntry], ResizeObserver[F]) => F[Unit]
+      callback: (List[ResizeObserverEntry[F]], ResizeObserver[F]) => F[Unit]
   )(implicit F: Async[F]): Resource[F, ResizeObserver[F]] = for {
     dispatcher <- Dispatcher.parallel[F]
     jsObserver <- Resource.make(
       F.delay(
         new dom.ResizeObserver((a, b) =>
-          dispatcher.unsafeRunAndForget(callback(a.toList, fromJsObserver(b)))
+          dispatcher.unsafeRunAndForget(
+            callback(a.toList.map(ResizeObserverEntry.fromJS), fromJS(b))
+          )
         )
       )
     )(obs => F.delay(obs.disconnect()))
-  } yield fromJsObserver(jsObserver)
+  } yield fromJS(jsObserver)
 
-  private def fromJsObserver[F[_]](
+  private def fromJS[F[_]](
       jsObserver: dom.ResizeObserver
   )(implicit F: Sync[F]): ResizeObserver[F] =
     new ResizeObserver[F] {

dom/src/main/scala/fs2/dom/ResizeObserverEntry.scala

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2022 Arman Bilge
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package fs2.dom
+
+import org.scalajs.dom
+
+abstract class ResizeObserverEntry[F[_]] private[dom] {
+
+  def target: Element[F]
+
+  def borderBoxSize: List[dom.ResizeObserverSize]
+
+  def contentBoxSize: List[dom.ResizeObserverSize]
+
+  def contentRect: dom.DOMRectReadOnly
+
+}
+
+object ResizeObserverEntry {
+
+  private[dom] def fromJS[F[_]](entry: dom.ResizeObserverEntry) = new ResizeObserverEntry[F] {
+
+    def target: Element[F] = entry.target.asInstanceOf[Element[F]]
+
+    def borderBoxSize: List[dom.ResizeObserverSize] = entry.borderBoxSize.toList
+
+    def contentBoxSize: List[dom.ResizeObserverSize] = entry.contentBoxSize.toList
+
+    def contentRect: dom.DOMRectReadOnly = entry.contentRect
+
+  }
+
+}