refactor compose-html

SciProgCentre · Feb 12, 2024 · d90c1ed · d90c1ed
1 parent 38d6a9c
commit d90c1ed
Show file tree

Hide file tree

Showing 21 changed files with 143 additions and 88 deletions.
diff --git a/demo/muon-monitor/build.gradle.kts b/demo/muon-monitor/build.gradle.kts
@@ -30,7 +30,6 @@ kscience {
 
     commonMain {
         implementation(projects.visionforgeSolid)
-        implementation(projects.visionforgeComposeHtml)
     }
     jvmMain {
         implementation("org.apache.commons:commons-math3:3.6.1")
@@ -40,12 +39,15 @@ kscience {
         implementation("ch.qos.logback:logback-classic:1.2.11")
     }
     jsMain {
+//        implementation(projects.visionforgeComposeHtml)
         implementation(projects.visionforgeThreejs)
         //implementation(devNpm("webpack-bundle-analyzer", "4.4.0"))
     }
 }
+kotlin{
+    explicitApi = null
+}
 
-kotlin.explicitApi = null
 
 application {
     mainClass.set("ru.mipt.npm.muon.monitor.server.MMServerKt")

diff --git a/visionforge-compose-html/build.gradle.kts b/visionforge-compose-html/build.gradle.kts
@@ -4,9 +4,8 @@ plugins {
 }
 
 kscience {
-    jvm()
     js()
-//    wasm()
+    jvm()
 }
 
 kotlin {
@@ -15,23 +14,22 @@ kotlin {
         commonMain {
             dependencies {
                 api(projects.visionforgeCore)
-                api(compose.runtime)
             }
         }
-
-        val jvmMain by getting {
-            dependencies {
-                api(compose.foundation)
-                api(compose.material)
-                api(compose.preview)
+        jvmMain{
+            //need this to placate compose compiler in MPP applications
+            dependencies{
+                api(compose.runtime)
             }
         }
 
-        val jsMain by getting {
+        jsMain{
             dependencies {
-                api(compose.html.core)
                 api("app.softwork:bootstrap-compose:0.1.15")
                 api("app.softwork:bootstrap-compose-icons:0.1.15")
+
+                api(compose.runtime)
+                api(compose.html.core)
             }
         }
     }

diff --git a/...visionforge/html/ComposeVisionRenderer.kt → ...onforge/html/ComposeHtmlVisionRenderer.kt b/...visionforge/html/ComposeVisionRenderer.kt → ...onforge/html/ComposeHtmlVisionRenderer.kt
@@ -9,20 +9,19 @@ import space.kscience.dataforge.meta.Meta
 import space.kscience.dataforge.names.Name
 import space.kscience.visionforge.ElementVisionRenderer
 import space.kscience.visionforge.Vision
-import space.kscience.visionforge.VisionClient
 
 /**
  * An [ElementVisionRenderer] that could be used directly in Compose-html as well as a stand-alone renderer
  */
-public interface ComposeVisionRenderer: ElementVisionRenderer {
+public interface ComposeHtmlVisionRenderer : ElementVisionRenderer {
 
     @Composable
-    public fun DOMScope<Element>.render(client: VisionClient, name: Name, vision: Vision, meta: Meta)
+    public fun DOMScope<Element>.render(name: Name, vision: Vision, meta: Meta)
 
-    override fun render(element: Element, client: VisionClient, name: Name, vision: Vision, meta: Meta) {
+    override fun render(element: Element, name: Name, vision: Vision, meta: Meta) {
         renderComposable(element) {
             Style(VisionForgeStyles)
-            render(client, name, vision, meta)
+            render(name, vision, meta)
         }
     }
 

diff --git a/...science/visionforge/html/composeVision.kt → ...nce/visionforge/html/composeHtmlVision.kt b/...science/visionforge/html/composeVision.kt → ...nce/visionforge/html/composeHtmlVision.kt
@@ -48,7 +48,7 @@ public fun Vision(
     }
 
     DisposableEffect(vision, name, renderer, meta) {
-        renderer.render(scopeElement, client, name, vision, meta)
+        renderer.render(scopeElement, name, vision, meta)
         onDispose {
             scopeElement.clear()
         }

diff --git a/visionforge-compose-mpp/build.gradle.kts b/visionforge-compose-mpp/build.gradle.kts
@@ -5,7 +5,7 @@ plugins {
 
 kscience {
     jvm()
-    wasm()
+//    wasm()
 }
 
 kotlin {
@@ -16,6 +16,10 @@ kotlin {
                 api(projects.visionforgeCore)
                 api(compose.runtime)
                 api(compose.foundation)
+            }
+        }
+        jvmMain{
+            dependencies{
                 api(compose.material)
                 api(compose.preview)
             }

diff --git a/...ose-mpp/src/commonMain/kotlin/space/kscience/visionforge/compose/ComposeVisionRenderer.kt b/...ose-mpp/src/commonMain/kotlin/space/kscience/visionforge/compose/ComposeVisionRenderer.kt
@@ -0,0 +1,15 @@
+package space.kscience.visionforge.compose
+
+import androidx.compose.runtime.Composable
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.names.Name
+import space.kscience.visionforge.Vision
+import space.kscience.visionforge.VisionClient
+
+public interface ComposeVisionRenderer {
+    public fun rateVision(vision: Vision): Int
+    @Composable
+    public fun render(client: VisionClient, name: Name, vision: Vision, meta: Meta)
+
+    public companion object
+}
diff --git a/...rge-compose-mpp/src/commonMain/kotlin/space/kscience/visionforge/compose/composeVision.kt b/...rge-compose-mpp/src/commonMain/kotlin/space/kscience/visionforge/compose/composeVision.kt
@@ -0,0 +1,24 @@
+package space.kscience.visionforge.compose
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import space.kscience.dataforge.context.Context
+import space.kscience.dataforge.meta.Meta
+import space.kscience.dataforge.names.Name
+import space.kscience.dataforge.names.asName
+import space.kscience.visionforge.Vision
+
+
+/**
+ * Render an Element vision via injected vision renderer inside compose-html
+ */
+@Composable
+public fun Vision(
+    context: Context,
+    vision: Vision,
+    name: Name = "@vision[${vision.hashCode().toString(16)}]".asName(),
+    meta: Meta = Meta.EMPTY,
+    modifier: Modifier = Modifier,
+) {
+
+}
diff --git a/visionforge-core/build.gradle.kts b/visionforge-core/build.gradle.kts
@@ -8,7 +8,7 @@ kscience {
     jvm()
     js()
     native()
-//    wasm()
+    wasm()
     useCoroutines()
     commonMain {
         api("space.kscience:dataforge-context:$dataforgeVersion")

diff --git a/visionforge-core/src/commonMain/kotlin/space/kscience/visionforge/ControlVision.kt b/visionforge-core/src/commonMain/kotlin/space/kscience/visionforge/ControlVision.kt
@@ -2,12 +2,11 @@ package space.kscience.visionforge
 
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
-import kotlinx.coroutines.flow.SharedFlow
-import kotlinx.coroutines.flow.filterIsInstance
-import kotlinx.coroutines.flow.launchIn
-import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.launch
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
+import kotlinx.serialization.Transient
 import space.kscience.dataforge.meta.*
 import space.kscience.dataforge.names.Name
 import space.kscience.dataforge.names.parseAsName
@@ -23,6 +22,9 @@ public abstract class VisionControlEvent : VisionEvent, MetaRepr {
 public interface ControlVision : Vision {
     public val controlEventFlow: SharedFlow<VisionControlEvent>
 
+    /**
+     * Fire a [VisionControlEvent] on this [ControlVision]
+     */
     public suspend fun dispatchControlEvent(event: VisionControlEvent)
 
     override suspend fun receiveEvent(event: VisionEvent) {
@@ -32,6 +34,28 @@ public interface ControlVision : Vision {
     }
 }
 
+public fun ControlVision.asyncControlEvent(
+    event: VisionControlEvent,
+    scope: CoroutineScope = manager?.context ?: error("Can't fire asynchronous event for an orphan vision. Provide a scope."),
+) {
+    scope.launch { dispatchControlEvent(event) }
+}
+
+
+@Serializable
+public abstract class AbstractControlVision : AbstractVision(), ControlVision {
+
+    @Transient
+    private val mutableControlEventFlow = MutableSharedFlow<VisionControlEvent>()
+
+    override val controlEventFlow: SharedFlow<VisionControlEvent>
+        get() = mutableControlEventFlow
+
+    override suspend fun dispatchControlEvent(event: VisionControlEvent) {
+        mutableControlEventFlow.emit(event)
+    }
+}
+
 
 /**
  * An event for submitting changes

diff --git a/visionforge-core/src/commonMain/kotlin/space/kscience/visionforge/html/VisionOfHtml.kt b/visionforge-core/src/commonMain/kotlin/space/kscience/visionforge/html/VisionOfHtml.kt
@@ -2,21 +2,21 @@ package space.kscience.visionforge.html
 
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
-import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.flow.filterIsInstance
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
 import kotlinx.html.DIV
 import kotlinx.html.InputType
 import kotlinx.html.div
 import kotlinx.html.stream.createHTML
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
-import kotlinx.serialization.Transient
 import space.kscience.dataforge.meta.*
 import space.kscience.dataforge.names.asName
 import space.kscience.visionforge.*
 
 
-@Serializable
-public abstract class VisionOfHtml : AbstractVision() {
+public interface VisionOfHtml : Vision {
     public var classes: Set<String>
         get() = properties[::classes.name, false].stringList?.toSet() ?: emptySet()
         set(value) {
@@ -26,7 +26,7 @@ public abstract class VisionOfHtml : AbstractVision() {
 
 @Serializable
 @SerialName("html.plain")
-public class VisionOfPlainHtml : VisionOfHtml() {
+public class VisionOfPlainHtml : AbstractVision(), VisionOfHtml {
     public var content: String? by properties.string()
 }
 
@@ -59,26 +59,11 @@ public enum class InputFeedbackMode {
     NONE
 }
 
-@Serializable
-public abstract class VisionOfHtmlControl: VisionOfHtml(), ControlVision{
-
-    @Transient
-    private val mutableControlEventFlow = MutableSharedFlow<VisionControlEvent>()
-
-    override val controlEventFlow: SharedFlow<VisionControlEvent>
-        get() = mutableControlEventFlow
-
-    override suspend fun dispatchControlEvent(event: VisionControlEvent) {
-        mutableControlEventFlow.emit(event)
-    }
-}
-
-
 @Serializable
 @SerialName("html.input")
 public open class VisionOfHtmlInput(
     public val inputType: String,
-) : VisionOfHtmlControl() {
+) : AbstractControlVision(), VisionOfHtml {
     public var value: Value? by properties.value()
     public var disabled: Boolean by properties.boolean { false }
     public var fieldName: String? by properties.string()

diff --git a/visionforge-core/src/commonMain/kotlin/space/kscience/visionforge/html/VisionOfHtmlForm.kt b/visionforge-core/src/commonMain/kotlin/space/kscience/visionforge/html/VisionOfHtmlForm.kt
@@ -8,6 +8,7 @@ import kotlinx.serialization.Serializable
 import space.kscience.dataforge.meta.Meta
 import space.kscience.dataforge.meta.node
 import space.kscience.dataforge.meta.string
+import space.kscience.visionforge.AbstractControlVision
 import space.kscience.visionforge.DataControl
 import space.kscience.visionforge.onSubmit
 
@@ -18,7 +19,7 @@ import space.kscience.visionforge.onSubmit
 @SerialName("html.form")
 public class VisionOfHtmlForm(
     public val formId: String,
-) : VisionOfHtmlControl(), DataControl {
+) : AbstractControlVision(), DataControl, VisionOfHtml {
     public var values: Meta? by properties.node()
 }
 
@@ -45,7 +46,7 @@ public fun VisionOfHtmlForm.onFormSubmit(scope: CoroutineScope, block: (Meta?) -
 
 @Serializable
 @SerialName("html.button")
-public class VisionOfHtmlButton : VisionOfHtmlControl(), DataControl {
+public class VisionOfHtmlButton : AbstractControlVision(), DataControl, VisionOfHtml {
     public var label: String? by properties.string()
 }
 

diff --git a/visionforge-core/src/jsMain/kotlin/space/kscience/visionforge/ElementVisionRenderer.kt b/visionforge-core/src/jsMain/kotlin/space/kscience/visionforge/ElementVisionRenderer.kt
@@ -30,7 +30,6 @@ public interface ElementVisionRenderer {
      */
     public fun render(
         element: Element,
-        client: VisionClient,
         name: Name,
         vision: Vision,
         meta: Meta = Meta.EMPTY,
@@ -49,27 +48,26 @@ public interface ElementVisionRenderer {
 public class SingleTypeVisionRenderer<T : Vision>(
     public val kClass: KClass<T>,
     private val acceptRating: Int = ElementVisionRenderer.DEFAULT_RATING,
-    private val renderFunction: TagConsumer<HTMLElement>.(name: Name, client: VisionClient, vision: T, meta: Meta) -> Unit,
+    private val renderFunction: TagConsumer<HTMLElement>.(name: Name, vision: T, meta: Meta) -> Unit,
 ) : ElementVisionRenderer {
 
     override fun rateVision(vision: Vision): Int =
         if (vision::class == kClass) acceptRating else ElementVisionRenderer.ZERO_RATING
 
     override fun render(
         element: Element,
-        client: VisionClient,
         name: Name,
         vision: Vision,
         meta: Meta,
     ) {
         element.clear()
         element.append {
-            renderFunction(name, client, kClass.cast(vision), meta)
+            renderFunction(name, kClass.cast(vision), meta)
         }
     }
 }
 
 public inline fun <reified T : Vision> ElementVisionRenderer(
     acceptRating: Int = ElementVisionRenderer.DEFAULT_RATING,
-    noinline renderFunction: TagConsumer<HTMLElement>.(name: Name, client: VisionClient, vision: T, meta: Meta) -> Unit,
+    noinline renderFunction: TagConsumer<HTMLElement>.(name: Name, vision: T, meta: Meta) -> Unit,
 ): ElementVisionRenderer = SingleTypeVisionRenderer(T::class, acceptRating, renderFunction)
diff --git a/visionforge-core/src/jsMain/kotlin/space/kscience/visionforge/JsVisionClient.kt b/visionforge-core/src/jsMain/kotlin/space/kscience/visionforge/JsVisionClient.kt
@@ -96,7 +96,13 @@ public class JsVisionClient : AbstractPlugin(), VisionClient {
         vision.setAsRoot(visionManager)
         val renderer: ElementVisionRenderer =
             findRendererFor(vision) ?: error("Could not find renderer for ${vision::class}")
-        renderer.render(element, this, name, vision, outputMeta)
+        //subscribe to a backwards events propagation for control visions
+        if(vision is ControlVision){
+            vision.controlEventFlow.onEach {
+                sendEvent(name,it)
+            }.launchIn(context)
+        }
+        renderer.render(element, name, vision, outputMeta)
     }
 
     private fun startVisionUpdate(element: Element, visionName: Name, vision: Vision, outputMeta: Meta) {