Revive HtmlSchelm and CssSchelm helpers

core/src/main/scala/io/taig/schelm/HtmlSchelm.scala

@@ -1,20 +1,22 @@
-//package io.taig.schelm
-//
-//import cats.effect.ConcurrentEffect
-//
-//object HtmlSchelm {
-//  def apply[F[_]: ConcurrentEffect, Event, Node](
-//      manager: EventManager[F, Event],
-//      dom: Dom[F, Event, Node]
-//  ): Schelm[F, Event, Node, Html[Event], Reference[Event, Node], HtmlDiff[
-//    Event
-//  ]] =
-//    Schelm(
-//      dom,
-//      manager,
-//      HtmlRenderer(dom),
-//      ReferenceAttacher(dom),
-//      HtmlDiffer[Event],
-//      ReferencePatcher(HtmlRenderer(dom), dom)
-//    )
-//}
+package io.taig.schelm
+
+import cats.effect.ConcurrentEffect
+
+object HtmlSchelm {
+  def apply[F[_]: ConcurrentEffect, A](
+      manager: EventManager[F, A],
+      dom: Dom[F, A]
+  ): Schelm[F, A, Html[A], Reference[A], HtmlDiff[
+    A
+  ]] = {
+    val renderer = HtmlRenderer(dom)
+    Schelm(
+      dom,
+      manager,
+      renderer,
+      ReferenceAttacher(dom),
+      HtmlDiffer[A],
+      ReferencePatcher(dom, renderer)
+    )
+  }
+}

css/src/main/scala/io/taig/schelm/css/CssSchelm.scala

@@ -0,0 +1,21 @@
+package io.taig.schelm.css
+
+import cats.effect.ConcurrentEffect
+import io.taig.schelm._
+
+object CssSchelm {
+  def apply[F[_]: ConcurrentEffect, A](
+      manager: EventManager[F, A],
+      dom: Dom[F, A]
+  ): Schelm[F, A, StyledHtml[A], StyledReference[A], StyledHtmlDiff[A]] = {
+    val renderer = HtmlRenderer(dom)
+    Schelm(
+      dom,
+      manager,
+      StyledHtmlRenderer(renderer),
+      StyledReferenceAttacher(dom),
+      StyledHtmlDiffer[A],
+      StyledReferencePatcher(dom, renderer)
+    )
+  }
+}

css/src/main/scala/io/taig/schelm/css/StyledReferencePatcher.scala

@@ -7,7 +7,7 @@ import io.taig.schelm._
 import io.taig.schelm.css.internal.StyleHelpers
 
 final class StyledReferencePatcher[F[_]: Monad, A](
-    style: Element,
+    dom: Dom[F, A],
     html: Patcher[F, Reference[A], HtmlDiff[A]],
     stylesheet: StylesheetPatcher[F, A]
 ) extends Patcher[F, StyledReference[A], StyledHtmlDiff[A]] {
@@ -16,33 +16,33 @@ final class StyledReferencePatcher[F[_]: Monad, A](
       diff: StyledHtmlDiff[A],
       path: Path
   ): F[StyledReference[A]] =
-    diff match {
-      case Ior.Left(left) =>
-        html
-          .patch(reference.reference, left, path)
-          .map(StyledReference(_, reference.stylesheet))
-      case Ior.Right(right) =>
-        stylesheet
-          .patch(style, reference.stylesheet, right)
-          .map(StyledReference(reference.reference, _))
-      case Ior.Both(left, right) =>
-        for {
-          html <- html.patch(reference.reference, left, path)
-          stylesheet <- stylesheet.patch(style, reference.stylesheet, right)
-        } yield StyledReference(html, stylesheet)
+    StyleHelpers.getOrCreateStyleElement(dom).flatMap { style =>
+      diff match {
+        case Ior.Left(left) =>
+          html
+            .patch(reference.reference, left, path)
+            .map(StyledReference(_, reference.stylesheet))
+        case Ior.Right(right) =>
+          stylesheet
+            .patch(style, reference.stylesheet, right)
+            .map(StyledReference(reference.reference, _))
+        case Ior.Both(left, right) =>
+          for {
+            html <- html.patch(reference.reference, left, path)
+            stylesheet <- stylesheet.patch(style, reference.stylesheet, right)
+          } yield StyledReference(html, stylesheet)
+      }
     }
 }
 
 object StyledReferencePatcher {
-  def apply[F[_]: MonadError[?[_], Throwable], Event](
-      dom: Dom[F, Event],
-      renderer: Renderer[F, Html[Event], Reference[Event]]
-  ): F[Patcher[F, StyledReference[Event], StyledHtmlDiff[Event]]] =
-    StyleHelpers.getOrCreateStyleElement(dom).map { style =>
-      new StyledReferencePatcher[F, Event](
-        style,
-        ReferencePatcher(dom, renderer),
-        StylesheetPatcher(dom)
-      )
-    }
+  def apply[F[_]: MonadError[?[_], Throwable], A](
+      dom: Dom[F, A],
+      renderer: Renderer[F, Html[A], Reference[A]]
+  ): Patcher[F, StyledReference[A], StyledHtmlDiff[A]] =
+    new StyledReferencePatcher[F, A](
+      dom,
+      ReferencePatcher(dom, renderer),
+      StylesheetPatcher(dom)
+    )
 }

playground/js/src/main/scala/io/taig/schelm/Playground.scala

@@ -6,21 +6,11 @@ import io.taig.schelm.css._
 import io.taig.schelm.playground.{App, Event, State}
 
 object Playground extends IOApp {
-  override def run(args: List[String]): IO[ExitCode] = {
+  override def run(args: List[String]): IO[ExitCode] =
     for {
       manager <- EventManager.unbounded[IO, Event]
       dom <- BrowserDom[IO, Event](manager)
-      renderer = HtmlRenderer(dom)
-      attacher = StyledReferenceAttacher(dom)
-      patcher <- StyledReferencePatcher(dom, renderer)
-      schelm = Schelm(
-        dom,
-        manager,
-        StyledHtmlRenderer(renderer),
-        attacher,
-        StyledHtmlDiffer[Event],
-        patcher
-      )
+      schelm = CssSchelm(manager, dom)
       _ <- schelm.start(
         "main",
         State(),
@@ -30,5 +20,4 @@ object Playground extends IOApp {
         Stream.empty
       )
     } yield ExitCode.Success
-  }
 }