@json-eval-rs/react-native 0.0.28

package/android/src/main/java/com/jsonevalrs/JsonEvalRsModule.kt

@@ -0,0 +1,532 @@
+package com.jsonevalrs
+
+import com.facebook.react.bridge.*
+import com.facebook.react.module.annotations.ReactModule
+
+@ReactModule(name = JsonEvalRsModule.NAME)
+class JsonEvalRsModule(reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+
+    override fun getName(): String {
+        return NAME
+    }
+
+    companion object {
+        const val NAME = "JsonEvalRs"
+
+        init {
+            try {
+                System.loadLibrary("json_eval_rs")
+                System.loadLibrary("json_eval_rn")
+            } catch (e: UnsatisfiedLinkError) {
+                e.printStackTrace()
+            }
+        }
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    fun create(
+        schema: String,
+        context: String?,
+        data: String?
+    ): String {
+        return nativeCreate(schema, context ?: "", data ?: "")
+    }
+
+    @ReactMethod
+    fun evaluate(
+        handle: String,
+        data: String,
+        context: String?,
+        promise: Promise
+    ) {
+        nativeEvaluateAsync(handle, data, context ?: "", promise)
+    }
+
+    @ReactMethod
+    fun validate(
+        handle: String,
+        data: String,
+        context: String?,
+        promise: Promise
+    ) {
+        nativeValidateAsync(handle, data, context ?: "", promise)
+    }
+
+    @ReactMethod
+    fun evaluateDependents(
+        handle: String,
+        changedPathsJson: String,
+        data: String?,
+        context: String?,
+        reEvaluate: Boolean,
+        promise: Promise
+    ) {
+        nativeEvaluateDependentsAsync(handle, changedPathsJson, data ?: "", context ?: "", reEvaluate, promise)
+    }
+
+    @ReactMethod
+    fun getEvaluatedSchema(
+        handle: String,
+        skipLayout: Boolean,
+        promise: Promise
+    ) {
+        nativeGetEvaluatedSchemaAsync(handle, skipLayout, promise)
+    }
+
+    @ReactMethod
+    fun getSchemaValue(
+        handle: String,
+        promise: Promise
+    ) {
+        nativeGetSchemaValueAsync(handle, promise)
+    }
+
+    @ReactMethod
+    fun getEvaluatedSchemaWithoutParams(
+        handle: String,
+        skipLayout: Boolean,
+        promise: Promise
+    ) {
+        nativeGetEvaluatedSchemaWithoutParamsAsync(handle, skipLayout, promise)
+    }
+
+    @ReactMethod
+    fun getEvaluatedSchemaByPath(
+        handle: String,
+        path: String,
+        skipLayout: Boolean,
+        promise: Promise
+    ) {
+        nativeGetEvaluatedSchemaByPathAsync(handle, path, skipLayout, promise)
+    }
+
+    @ReactMethod
+    fun getEvaluatedSchemaByPaths(
+        handle: String,
+        pathsJson: String,
+        skipLayout: Boolean,
+        promise: Promise
+    ) {
+        nativeGetEvaluatedSchemaByPathsAsync(handle, pathsJson, skipLayout, promise)
+    }
+
+    @ReactMethod
+    fun getSchemaByPath(
+        handle: String,
+        path: String,
+        promise: Promise
+    ) {
+        nativeGetSchemaByPathAsync(handle, path, promise)
+    }
+
+    @ReactMethod
+    fun getSchemaByPaths(
+        handle: String,
+        pathsJson: String,
+        promise: Promise
+    ) {
+        nativeGetSchemaByPathsAsync(handle, pathsJson, promise)
+    }
+
+    @ReactMethod
+    fun reloadSchema(
+        handle: String,
+        schema: String,
+        context: String?,
+        data: String?,
+        promise: Promise
+    ) {
+        nativeReloadSchemaAsync(handle, schema, context ?: "", data ?: "", promise)
+    }
+
+    @ReactMethod
+    fun reloadSchemaMsgpack(
+        handle: String,
+        schemaMsgpack: ReadableArray,
+        context: String?,
+        data: String?,
+        promise: Promise
+    ) {
+        // Convert ReadableArray to ByteArray
+        val byteArray = ByteArray(schemaMsgpack.size())
+        for (i in 0 until schemaMsgpack.size()) {
+            byteArray[i] = schemaMsgpack.getInt(i).toByte()
+        }
+        nativeReloadSchemaMsgpackAsync(handle, byteArray, context ?: "", data ?: "", promise)
+    }
+
+    @ReactMethod
+    fun reloadSchemaFromCache(
+        handle: String,
+        cacheKey: String,
+        context: String?,
+        data: String?,
+        promise: Promise
+    ) {
+        nativeReloadSchemaFromCacheAsync(handle, cacheKey, context ?: "", data ?: "", promise)
+    }
+
+    @ReactMethod
+    fun createFromMsgpack(
+        schemaMsgpack: ReadableArray,
+        context: String?,
+        data: String?,
+        promise: Promise
+    ) {
+        try {
+            // Convert ReadableArray to ByteArray
+            val byteArray = ByteArray(schemaMsgpack.size())
+            for (i in 0 until schemaMsgpack.size()) {
+                byteArray[i] = schemaMsgpack.getInt(i).toByte()
+            }
+            val handle = nativeCreateFromMsgpack(byteArray, context ?: "", data ?: "")
+            promise.resolve(handle)
+        } catch (e: Exception) {
+            promise.reject("CREATE_FROM_MSGPACK_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun createFromCache(
+        cacheKey: String,
+        context: String?,
+        data: String?,
+        promise: Promise
+    ) {
+        try {
+            val handle = nativeCreateFromCache(cacheKey, context ?: "", data ?: "")
+            promise.resolve(handle)
+        } catch (e: Exception) {
+            promise.reject("CREATE_FROM_CACHE_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun cacheStats(
+        handle: String,
+        promise: Promise
+    ) {
+        nativeCacheStatsAsync(handle, promise)
+    }
+
+    @ReactMethod
+    fun clearCache(
+        handle: String,
+        promise: Promise
+    ) {
+        nativeClearCacheAsync(handle, promise)
+    }
+
+    @ReactMethod
+    fun cacheLen(
+        handle: String,
+        promise: Promise
+    ) {
+        nativeCacheLenAsync(handle, promise)
+    }
+
+    @ReactMethod
+    fun enableCache(
+        handle: String,
+        promise: Promise
+    ) {
+        nativeEnableCacheAsync(handle, promise)
+    }
+
+    @ReactMethod
+    fun disableCache(
+        handle: String,
+        promise: Promise
+    ) {
+        nativeDisableCacheAsync(handle, promise)
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    fun isCacheEnabled(
+        handle: String
+    ): Boolean {
+        return nativeIsCacheEnabled(handle)
+    }
+
+    @ReactMethod
+    fun validatePaths(
+        handle: String,
+        data: String,
+        context: String?,
+        paths: ReadableArray?,
+        promise: Promise
+    ) {
+        val pathsJson = if (paths != null) arrayToJsonString(paths) else ""
+        nativeValidatePathsAsync(handle, data, context ?: "", pathsJson, promise)
+    }
+
+    @ReactMethod
+    fun resolveLayout(
+        handle: String,
+        evaluate: Boolean,
+        promise: Promise
+    ) {
+        nativeResolveLayoutAsync(handle, evaluate, promise)
+    }
+
+    @ReactMethod
+    fun compileAndRunLogic(
+        handle: String,
+        logicStr: String,
+        data: String?,
+        context: String?,
+        promise: Promise
+    ) {
+        nativeCompileAndRunLogicAsync(handle, logicStr, data ?: "", context ?: "", promise)
+    }
+
+    @ReactMethod
+    fun compileLogic(
+        handle: String,
+        logicStr: String,
+        promise: Promise
+    ) {
+        try {
+            val logicId = nativeCompileLogic(handle, logicStr)
+            if (logicId == 0.0) {
+                promise.reject("COMPILE_LOGIC_ERROR", "Failed to compile logic")
+            } else {
+                promise.resolve(logicId)
+            }
+        } catch (e: Exception) {
+            promise.reject("COMPILE_LOGIC_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun runLogic(
+        handle: String,
+        logicId: Double,
+        data: String?,
+        context: String?,
+        promise: Promise
+    ) {
+        nativeRunLogicAsync(handle, logicId, data ?: "", context ?: "", promise)
+    }
+
+    // ========================================================================
+    // Subform Methods
+    // ========================================================================
+
+    @ReactMethod
+    fun evaluateSubform(
+        handle: String,
+        subformPath: String,
+        data: String,
+        context: String?,
+        promise: Promise
+    ) {
+        nativeEvaluateSubformAsync(handle, subformPath, data, context ?: "", promise)
+    }
+
+    @ReactMethod
+    fun validateSubform(
+        handle: String,
+        subformPath: String,
+        data: String,
+        context: String?,
+        promise: Promise
+    ) {
+        nativeValidateSubformAsync(handle, subformPath, data, context ?: "", promise)
+    }
+
+    @ReactMethod
+    fun evaluateDependentsSubform(
+        handle: String,
+        subformPath: String,
+        changedPath: String,
+        data: String?,
+        context: String?,
+        promise: Promise
+    ) {
+        nativeEvaluateDependentsSubformAsync(handle, subformPath, changedPath, data ?: "", context ?: "", promise)
+    }
+
+    @ReactMethod
+    fun resolveLayoutSubform(
+        handle: String,
+        subformPath: String,
+        evaluate: Boolean,
+        promise: Promise
+    ) {
+        nativeResolveLayoutSubformAsync(handle, subformPath, evaluate, promise)
+    }
+
+    @ReactMethod
+    fun getEvaluatedSchemaSubform(
+        handle: String,
+        subformPath: String,
+        resolveLayout: Boolean,
+        promise: Promise
+    ) {
+        nativeGetEvaluatedSchemaSubformAsync(handle, subformPath, resolveLayout, promise)
+    }
+
+    @ReactMethod
+    fun getSchemaValueSubform(
+        handle: String,
+        subformPath: String,
+        promise: Promise
+    ) {
+        nativeGetSchemaValueSubformAsync(handle, subformPath, promise)
+    }
+
+    @ReactMethod
+    fun getEvaluatedSchemaWithoutParamsSubform(
+        handle: String,
+        subformPath: String,
+        resolveLayout: Boolean,
+        promise: Promise
+    ) {
+        nativeGetEvaluatedSchemaWithoutParamsSubformAsync(handle, subformPath, resolveLayout, promise)
+    }
+
+    @ReactMethod
+    fun getEvaluatedSchemaByPathSubform(
+        handle: String,
+        subformPath: String,
+        schemaPath: String,
+        skipLayout: Boolean,
+        promise: Promise
+    ) {
+        nativeGetEvaluatedSchemaByPathSubformAsync(handle, subformPath, schemaPath, skipLayout, promise)
+    }
+
+    @ReactMethod
+    fun getEvaluatedSchemaByPathsSubform(
+        handle: String,
+        subformPath: String,
+        schemaPathsJson: String,
+        skipLayout: Boolean,
+        promise: Promise
+    ) {
+        nativeGetEvaluatedSchemaByPathsSubformAsync(handle, subformPath, schemaPathsJson, skipLayout, promise)
+    }
+
+    @ReactMethod
+    fun getSubformPaths(
+        handle: String,
+        promise: Promise
+    ) {
+        nativeGetSubformPathsAsync(handle, promise)
+    }
+
+    @ReactMethod
+    fun getSchemaByPathSubform(
+        handle: String,
+        subformPath: String,
+        schemaPath: String,
+        promise: Promise
+    ) {
+        nativeGetSchemaByPathSubformAsync(handle, subformPath, schemaPath, promise)
+    }
+
+    @ReactMethod
+    fun getSchemaByPathsSubform(
+        handle: String,
+        subformPath: String,
+        schemaPathsJson: String,
+        promise: Promise
+    ) {
+        nativeGetSchemaByPathsSubformAsync(handle, subformPath, schemaPathsJson, promise)
+    }
+
+    @ReactMethod
+    fun hasSubform(
+        handle: String,
+        subformPath: String,
+        promise: Promise
+    ) {
+        nativeHasSubformAsync(handle, subformPath, promise)
+    }
+
+    @ReactMethod(isBlockingSynchronousMethod = true)
+    fun dispose(
+        handle: String
+    ) {
+        nativeDispose(handle)
+    }
+
+    @ReactMethod
+    fun version(promise: Promise) {
+        try {
+            val ver = nativeVersion()
+            promise.resolve(ver)
+        } catch (e: Exception) {
+            promise.reject("VERSION_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun multiply(a: Double, b: Double, promise: Promise) {
+        promise.resolve(a * b)
+    }
+
+    private fun arrayToJsonString(array: ReadableArray): String {
+        val items = mutableListOf<String>()
+        for (i in 0 until array.size()) {
+            items.add("\"${array.getString(i)}\"")
+        }
+        return "[${items.joinToString(",")}]"
+    }
+
+    // Native methods
+    private external fun nativeCreate(schema: String, context: String, data: String): String
+    private external fun nativeCreateFromMsgpack(schemaMsgpack: ByteArray, context: String, data: String): String
+    private external fun nativeCreateFromCache(cacheKey: String, context: String, data: String): String
+    private external fun nativeEvaluateAsync(handle: String, data: String, context: String, promise: Promise)
+    private external fun nativeValidateAsync(handle: String, data: String, context: String, promise: Promise)
+    private external fun nativeEvaluateDependentsAsync(
+        handle: String,
+        changedPathsJson: String,
+        data: String,
+        context: String,
+        reEvaluate: Boolean,
+        promise: Promise
+    )
+    private external fun nativeGetEvaluatedSchemaAsync(handle: String, skipLayout: Boolean, promise: Promise)
+    private external fun nativeGetSchemaValueAsync(handle: String, promise: Promise)
+    private external fun nativeGetEvaluatedSchemaWithoutParamsAsync(handle: String, skipLayout: Boolean, promise: Promise)
+    private external fun nativeGetEvaluatedSchemaByPathAsync(handle: String, path: String, skipLayout: Boolean, promise: Promise)
+    private external fun nativeGetEvaluatedSchemaByPathsAsync(handle: String, pathsJson: String, skipLayout: Boolean, promise: Promise)
+    private external fun nativeGetSchemaByPathAsync(handle: String, path: String, promise: Promise)
+    private external fun nativeGetSchemaByPathsAsync(handle: String, pathsJson: String, promise: Promise)
+    private external fun nativeReloadSchemaAsync(handle: String, schema: String, context: String, data: String, promise: Promise)
+    private external fun nativeReloadSchemaMsgpackAsync(handle: String, schemaMsgpack: ByteArray, context: String, data: String, promise: Promise)
+    private external fun nativeReloadSchemaFromCacheAsync(handle: String, cacheKey: String, context: String, data: String, promise: Promise)
+    private external fun nativeCacheStatsAsync(handle: String, promise: Promise)
+    private external fun nativeClearCacheAsync(handle: String, promise: Promise)
+    private external fun nativeCacheLenAsync(handle: String, promise: Promise)
+    private external fun nativeEnableCacheAsync(handle: String, promise: Promise)
+    private external fun nativeDisableCacheAsync(handle: String, promise: Promise)
+    private external fun nativeIsCacheEnabled(handle: String): Boolean
+    private external fun nativeValidatePathsAsync(handle: String, data: String, context: String, pathsJson: String, promise: Promise)
+    private external fun nativeResolveLayoutAsync(handle: String, evaluate: Boolean, promise: Promise)
+    private external fun nativeCompileAndRunLogicAsync(handle: String, logicStr: String, data: String, context: String, promise: Promise)
+    private external fun nativeCompileLogic(handle: String, logicStr: String): Double
+    private external fun nativeRunLogicAsync(handle: String, logicId: Double, data: String, context: String, promise: Promise)
+    
+    // Subform native methods
+    private external fun nativeEvaluateSubformAsync(handle: String, subformPath: String, data: String, context: String, promise: Promise)
+    private external fun nativeValidateSubformAsync(handle: String, subformPath: String, data: String, context: String, promise: Promise)
+    private external fun nativeEvaluateDependentsSubformAsync(handle: String, subformPath: String, changedPath: String, data: String, context: String, promise: Promise)
+    private external fun nativeResolveLayoutSubformAsync(handle: String, subformPath: String, evaluate: Boolean, promise: Promise)
+    private external fun nativeGetEvaluatedSchemaSubformAsync(handle: String, subformPath: String, resolveLayout: Boolean, promise: Promise)
+    private external fun nativeGetSchemaValueSubformAsync(handle: String, subformPath: String, promise: Promise)
+    private external fun nativeGetEvaluatedSchemaWithoutParamsSubformAsync(handle: String, subformPath: String, resolveLayout: Boolean, promise: Promise)
+    private external fun nativeGetEvaluatedSchemaByPathSubformAsync(handle: String, subformPath: String, schemaPath: String, skipLayout: Boolean, promise: Promise)
+    private external fun nativeGetEvaluatedSchemaByPathsSubformAsync(handle: String, subformPath: String, schemaPathsJson: String, skipLayout: Boolean, promise: Promise)
+    private external fun nativeGetSchemaByPathSubformAsync(handle: String, subformPath: String, schemaPath: String, promise: Promise)
+    private external fun nativeGetSchemaByPathsSubformAsync(handle: String, subformPath: String, schemaPathsJson: String, promise: Promise)
+    private external fun nativeGetSubformPathsAsync(handle: String, promise: Promise)
+    private external fun nativeHasSubformAsync(handle: String, subformPath: String, promise: Promise)
+    
+    private external fun nativeDispose(handle: String)
+    private external fun nativeVersion(): String
+}

package/android/src/main/java/com/jsonevalrs/JsonEvalRsPackage.kt

@@ -0,0 +1,16 @@
+package com.jsonevalrs
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class JsonEvalRsPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(JsonEvalRsModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}