Merge pull request #13 from belousovgm/fix-some-problems-with-receiving-values

Fix js object serialization

Author: Alex009

.idea/copyright/IceRock.xml

@@ -35,7 +35,7 @@ allprojects {
 project build.gradle
 ```groovy
 dependencies {
-    commonMainApi("dev.icerock.moko:javascript:0.2.0")
+    commonMainApi("dev.icerock.moko:javascript:0.3.0")
 }
 ```
 

.idea/copyright/profiles_settings.xml

@@ -1,15 +1,15 @@
 [versions]
-kotlinTestVersion = "1.5.20"
+kotlinTestVersion = "1.6.21"
 androidAppCompatVersion = "1.2.0"
 materialDesignVersion = "1.0.0"
 androidLifecycleVersion = "2.1.0"
 androidCoreTestingVersion = "1.3.0"
 testJUnitExtVersion = "1.1.2"
-quickjsVersion = "0.9.0"
-coroutinesVersion = "1.5.0-native-mt"
-kotlinxSerializationVersion = "1.1.0"
-mokoTestVersion = "0.4.0"
-mokoJavascriptVersion = "0.2.0"
+quickjsVersion = "0.9.2"
+coroutinesVersion = "1.6.0-native-mt"
+kotlinxSerializationVersion = "1.3.3"
+mokoTestVersion = "0.6.1"
+mokoJavascriptVersion = "0.3.0"
 
 
 [libraries]

README.md

@@ -10,8 +10,8 @@ repositories {
 }
 
 dependencies {
-    api("dev.icerock:mobile-multiplatform:0.12.0")
-    api("org.jetbrains.kotlin:kotlin-gradle-plugin:1.5.20")
-    api("com.android.tools.build:gradle:4.2.1")
+    api("dev.icerock:mobile-multiplatform:0.14.1")
+    api("org.jetbrains.kotlin:kotlin-gradle-plugin:1.6.21")
+    api("com.android.tools.build:gradle:7.0.1")
     api("io.gitlab.arturbosch.detekt:detekt-gradle-plugin:1.15.0")
 }

gradle/libs.versions.toml

@@ -11,16 +11,23 @@ plugins {
 
 kotlin {
     ios()
+    iosSimulatorArm64()
     android {
         publishLibraryVariants("release", "debug")
     }
     sourceSets {
+        val iosSimulatorArm64Main by getting
+        val iosSimulatorArm64Test by getting
+
         val mobileDeviceTest by creating
 
         val commonTest by getting
+        val iosMain by getting
         val iosTest by getting
         val androidAndroidTest by getting
 
+        iosSimulatorArm64Main.dependsOn(iosMain)
+        iosSimulatorArm64Test.dependsOn(iosTest)
 
         mobileDeviceTest.dependsOn(commonTest)
         iosTest.dependsOn(mobileDeviceTest)

javascript-build-logic/build.gradle.kts

@@ -2,12 +2,29 @@
  * Copyright 2021 IceRock MAG Inc. Use of this source code is governed by the Apache 2.0 license.
  */
 
+import org.gradle.api.tasks.testing.logging.TestExceptionFormat
+import org.gradle.api.tasks.testing.logging.TestLogEvent
+
 plugins {
     id("multiplatform-library-convention")
     id("dev.icerock.mobile.multiplatform.android-manifest")
     id("publication-convention")
 }
 
+android {
+    testOptions.unitTests.isIncludeAndroidResources = true
+    defaultConfig {
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+    }
+
+    sourceSets {
+        getByName("androidTest").java.srcDirs(
+            file("src/androidAndroidTest/kotlin"),
+            file("src/mobileDeviceTest/kotlin")
+        )
+    }
+}
+
 dependencies {
     androidMainImplementation(libs.quickjs)
     commonMainImplementation(libs.kotlinSerialization)
@@ -20,3 +37,16 @@ dependencies {
     androidTestImplementation(libs.testJUnitExt)
     androidTestImplementation(libs.testJUnitExtKtx)
 }
+
+tasks.withType<AbstractTestTask> {
+    testLogging {
+        exceptionFormat = TestExceptionFormat.FULL
+        events = setOf(
+            TestLogEvent.SKIPPED,
+            TestLogEvent.PASSED,
+            TestLogEvent.FAILED
+        )
+        showStandardStreams = true
+    }
+    outputs.upToDateWhen { false }
+}

javascript-build-logic/src/main/kotlin/multiplatform-library-convention.gradle.kts

@@ -0,0 +1,14 @@
+/*
+ * Copyright 2022 IceRock MAG Inc. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package dev.icerock.moko.javascript
+
+internal interface ContextProvider {
+    fun getBool(name: String): Boolean
+    fun getDouble(name: String): Double
+
+    fun getString(name: String): String
+
+    fun getScript(): String
+}

javascript/build.gradle.kts

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2022 IceRock MAG Inc. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package dev.icerock.moko.javascript
+
+internal class ContextProviderDynamic : ContextProvider {
+    var context: Map<String, JsType> = emptyMap()
+    var activeScript: String = ""
+
+    override fun getBool(name: String): Boolean {
+        return context[name]!!.boolValue()
+    }
+
+    override fun getDouble(name: String): Double {
+        return context[name]!!.doubleValue()
+    }
+
+    override fun getString(name: String): String {
+        val jsType: JsType = context[name]!!
+        return when (jsType) {
+            is JsType.Bool, is JsType.DoubleNum, JsType.Null -> throw IllegalArgumentException()
+            is JsType.Json -> jsType.value.toString()
+            is JsType.Str -> jsType.value
+        }
+    }
+
+    override fun getScript(): String = activeScript
+}

javascript/src/androidMain/kotlin/dev/icerock/moko/javascript/ContextProvider.kt

@@ -7,23 +7,44 @@ package dev.icerock.moko.javascript
 import app.cash.quickjs.QuickJs
 import app.cash.quickjs.QuickJsException
 import kotlinx.serialization.SerializationException
-import kotlinx.serialization.builtins.serializer
 import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonArray
 import kotlinx.serialization.json.JsonElement
 import kotlinx.serialization.json.JsonObject
 
 actual class JavaScriptEngine actual constructor() {
     private val quickJs: QuickJs = QuickJs.create()
     private val json: Json = Json.Default
+    private val jsContext: ContextProviderDynamic = ContextProviderDynamic()
 
     @Volatile
     var isClosed = false
         private set
 
-    actual fun evaluate(
-        context: Map<String, JsType>,
-        script: String
-    ): JsType {
+    init {
+        quickJs.set("mokoJsContext", ContextProvider::class.java, jsContext)
+        quickJs.evaluate(
+            """
+                function mokoJavaScriptProcessResult(result) {
+                    if (typeof result === 'object') return JSON.stringify(result);
+                    else if (typeof result === 'array') return JSON.stringify(result);
+                    else return result;
+                }
+            """.trimIndent()
+        )
+    }
+
+    actual fun setContextObjects(vararg context: Pair<String, JsType>) {
+        val scriptContext: Map<String, JsType> = context.toMap()
+        jsContext.context = scriptContext
+
+        val scriptWithContext: String = buildString {
+            fillContext(scriptContext)
+        }
+        quickJs.evaluate(scriptWithContext)
+    }
+
+    actual fun evaluate(context: Map<String, JsType>, script: String): JsType {
         if (isClosed) throw JavaScriptEvaluationException(message = "Engine already closed")
 
         return try {
@@ -43,37 +64,32 @@ actual class JavaScriptEngine actual constructor() {
         context: Map<String, JsType>,
         script: String
     ): JsType {
-        val scriptWithContext = convertContextMapToJsScript(context) + script + "\n"
-        val result = quickJs.evaluate(scriptWithContext)
-        return handleQuickJsResult(result)
-    }
-
-    // TODO fix pass of arguments - now wrapping of string and json invalid and will be broken on multilined strings
-    private fun convertContextMapToJsScript(context: Map<String, JsType>): String {
-        if (context.isEmpty()) return ""
+        jsContext.activeScript = script
+        jsContext.context = context
 
-        return context.mapNotNull { pair ->
-            prepareValueForJs(pair.value)?.let { "var ${pair.key} = $it;" }
-        }.joinToString(separator = "")
+        val scriptWithContext: String = buildString {
+            fillContext(context)
+            append("mokoJavaScriptProcessResult(eval(mokoJsContext.getScript()));")
+        }
+        val result: Any? = quickJs.evaluate(scriptWithContext)
+        return handleQuickJsResult(result)
     }
 
-    private fun prepareValueForJs(valueWrapper: JsType): String? {
-        return when (valueWrapper) {
-            is JsType.Bool -> valueWrapper.value.toString()
-            is JsType.DoubleNum -> valueWrapper.value.toString()
-            is JsType.Json -> valueWrapper.value.let {
-                Json.encodeToString(JsonElement.serializer(), it)
-            }.let {
-                it.replace("\"", "\\\"")
-            }.let {
-                "JSON.parse(\"$it\")"
-            }
-            is JsType.Str -> valueWrapper.value.let {
-                it.replace("\"", "\\\"")
-            }.let {
-                "\"$it\""
-            }
-            JsType.Null -> null
+    private fun StringBuilder.fillContext(context: Map<String, JsType>) {
+        context.forEach { (name, jsType) ->
+            append("const ")
+            append(name)
+            append(" = ")
+            append(
+                when (jsType) {
+                    is JsType.Bool -> "mokoJsContext.getBool('$name')"
+                    is JsType.DoubleNum -> "mokoJsContext.getDouble('$name')"
+                    is JsType.Json -> "JSON.parse(mokoJsContext.getString('$name'))"
+                    JsType.Null -> "null"
+                    is JsType.Str -> "mokoJsContext.getString('$name')"
+                }
+            )
+            append(";\n")
         }
     }
 
@@ -85,12 +101,9 @@ actual class JavaScriptEngine actual constructor() {
             is Double -> JsType.DoubleNum(result)
             is Float -> JsType.DoubleNum(result.toDouble())
             is String -> try {
-                val serializeResult = json.parseToJsonElement(result)
-                if (serializeResult is JsonObject) {
-                    JsType.Json(serializeResult)
-                } else {
-                    JsType.Str(result)
-                }
+                val jsonElement: JsonElement = json.parseToJsonElement(result)
+                if (jsonElement is JsonObject || jsonElement is JsonArray) JsType.Json(jsonElement)
+                else JsType.Str(result)
             } catch (ex: SerializationException) {
                 JsType.Str(result)
             } catch (ex: IllegalStateException) {