@fto-consult/expo-ui 6.37.3 → 6.37.5

package/node_modules/@react-native-async-storage/async-storage/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpers.kt

@@ -0,0 +1,86 @@
+package com.reactnativecommunity.asyncstorage.next
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
+import org.json.JSONException
+import org.json.JSONObject
+
+fun ReadableArray.toEntryList(): List<Entry> {
+    val list = mutableListOf<Entry>()
+    for (keyValue in this.toArrayList()) {
+        if (keyValue !is ArrayList<*> || keyValue.size != 2) {
+            throw AsyncStorageError.invalidKeyValueFormat()
+        }
+        val key = keyValue[0]
+        val value = keyValue[1]
+
+        if (key !is String) {
+            when (key) {
+                null -> throw AsyncStorageError.keyIsNull()
+                else -> throw AsyncStorageError.keyNotString()
+            }
+        }
+
+        if (value !is String) {
+            throw AsyncStorageError.valueNotString(key)
+        }
+
+        list.add(Entry(key, value))
+    }
+    return list
+}
+
+fun ReadableArray.toKeyList(): List<String> {
+    val list = this.toArrayList()
+
+    for (item in list) {
+        if (item !is String) {
+            throw AsyncStorageError.keyNotString()
+        }
+    }
+    return list as List<String>
+}
+
+fun List<Entry>.toKeyValueArgument(): ReadableArray {
+    val args = Arguments.createArray()
+
+    for (entry in this) {
+        val keyValue = Arguments.createArray()
+        keyValue.pushString(entry.key)
+        keyValue.pushString(entry.value)
+        args.pushArray(keyValue)
+    }
+
+    return args
+}
+
+fun String?.isValidJson(): Boolean {
+    if (this == null) return false
+
+    return try {
+        JSONObject(this)
+        true
+    } catch (e: JSONException) {
+        false
+    }
+}
+
+fun JSONObject.mergeWith(newObject: JSONObject): JSONObject {
+
+    val keys = newObject.keys()
+    val mergedObject = JSONObject(this.toString())
+
+    while (keys.hasNext()) {
+        val key = keys.next()
+        val curValue = this.optJSONObject(key)
+        val newValue = newObject.optJSONObject(key)
+
+        if (curValue != null && newValue != null) {
+            val merged = curValue.mergeWith(newValue)
+            mergedObject.put(key, merged)
+        } else {
+            mergedObject.put(key, newObject.get(key))
+        }
+    }
+    return mergedObject
+}

package/node_modules/@react-native-async-storage/async-storage/android/src/main/java/com/reactnativecommunity/asyncstorage/next/ErrorHelpers.kt

@@ -0,0 +1,39 @@
+package com.reactnativecommunity.asyncstorage.next
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Callback
+import kotlinx.coroutines.CoroutineExceptionHandler
+
+internal fun createExceptionHandler(cb: Callback): CoroutineExceptionHandler {
+    return CoroutineExceptionHandler { _, throwable ->
+        val error = Arguments.createMap()
+        if (throwable !is AsyncStorageError) {
+            error.putString(
+                "message", "Unexpected AsyncStorage error: ${throwable.localizedMessage}"
+            )
+        } else {
+            error.putString("message", throwable.errorMessage)
+        }
+
+        cb(error)
+    }
+}
+
+internal class AsyncStorageError private constructor(val errorMessage: String) :
+    Throwable(errorMessage) {
+
+    companion object {
+        fun keyIsNull() = AsyncStorageError("Key cannot be null.")
+
+        fun keyNotString() = AsyncStorageError("Provided key is not string. Only strings are supported as storage key.")
+
+        fun valueNotString(key: String?): AsyncStorageError {
+            val detail = if (key == null) "Provided value" else "Value for key \"$key\""
+            return AsyncStorageError("$detail is not a string. Only strings are supported as a value.")
+        }
+
+        fun invalidKeyValueFormat() =
+            AsyncStorageError("Invalid key-value format. Expected a list of [key, value] list.")
+
+    }
+}

package/node_modules/@react-native-async-storage/async-storage/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageModule.kt

@@ -0,0 +1,90 @@
+package com.reactnativecommunity.asyncstorage.next
+
+import android.content.Context
+import androidx.annotation.VisibleForTesting
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableArray
+import com.reactnativecommunity.asyncstorage.SerialExecutor
+import kotlinx.coroutines.CoroutineName
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.asExecutor
+import kotlinx.coroutines.launch
+
+class StorageModule(reactContext: ReactContext) : ReactContextBaseJavaModule(), CoroutineScope {
+    override fun getName() = "RNC_AsyncSQLiteDBStorage"
+
+    // this executor is not used by the module, but it must exists here due to
+    // Detox relying on this implementation detail to run
+    @VisibleForTesting
+    private val executor = SerialExecutor(Dispatchers.Main.asExecutor())
+
+    override val coroutineContext =
+        Dispatchers.IO + CoroutineName("AsyncStorageScope") + SupervisorJob()
+
+    private val storage = StorageSupplier.getInstance(reactContext)
+
+    companion object {
+        @JvmStatic
+        fun getStorageInstance(ctx: Context): AsyncStorageAccess {
+            return StorageSupplier.getInstance(ctx)
+        }
+    }
+
+    @ReactMethod
+    fun multiGet(keys: ReadableArray, cb: Callback) {
+        launch(createExceptionHandler(cb)) {
+            val entries = storage.getValues(keys.toKeyList())
+            cb(null, entries.toKeyValueArgument())
+        }
+    }
+
+    @ReactMethod
+    fun multiSet(keyValueArray: ReadableArray, cb: Callback) {
+        launch(createExceptionHandler(cb)) {
+            val entries = keyValueArray.toEntryList()
+            storage.setValues(entries)
+            cb(null)
+        }
+    }
+
+    @ReactMethod
+    fun multiRemove(keys: ReadableArray, cb: Callback) {
+        launch(createExceptionHandler(cb)) {
+            storage.removeValues(keys.toKeyList())
+            cb(null)
+        }
+    }
+
+    @ReactMethod
+    fun multiMerge(keyValueArray: ReadableArray, cb: Callback) {
+        launch(createExceptionHandler(cb)) {
+            val entries = keyValueArray.toEntryList()
+            storage.mergeValues(entries)
+            cb(null)
+        }
+    }
+
+    @ReactMethod
+    fun getAllKeys(cb: Callback) {
+        launch(createExceptionHandler(cb)) {
+            val keys = storage.getKeys()
+            val result = Arguments.createArray()
+            keys.forEach { result.pushString(it) }
+            cb.invoke(null, result)
+        }
+    }
+
+    @ReactMethod
+    fun clear(cb: Callback) {
+        launch(createExceptionHandler(cb)) {
+            storage.clear()
+            cb(null)
+        }
+    }
+}

package/node_modules/@react-native-async-storage/async-storage/android/src/main/java/com/reactnativecommunity/asyncstorage/next/StorageSupplier.kt

@@ -0,0 +1,161 @@
+package com.reactnativecommunity.asyncstorage.next
+
+import android.content.Context
+import android.util.Log
+import androidx.room.ColumnInfo
+import androidx.room.Dao
+import androidx.room.Database
+import androidx.room.Entity
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.PrimaryKey
+import androidx.room.Query
+import androidx.room.Room
+import androidx.room.RoomDatabase
+import androidx.room.Transaction
+import androidx.room.migration.Migration
+import androidx.sqlite.db.SupportSQLiteDatabase
+import org.json.JSONObject
+
+private const val DATABASE_VERSION = 2
+private const val DATABASE_NAME = "AsyncStorage"
+private const val TABLE_NAME = "Storage"
+private const val COLUMN_KEY = "key"
+private const val COLUMN_VALUE = "value"
+
+
+@Entity(tableName = TABLE_NAME)
+data class Entry(
+    @PrimaryKey @ColumnInfo(name = COLUMN_KEY) val key: String,
+    @ColumnInfo(name = COLUMN_VALUE) val value: String?
+)
+
+@Dao
+internal interface StorageDao {
+
+    @Transaction
+    @Query("SELECT * FROM $TABLE_NAME WHERE `$COLUMN_KEY` IN (:keys)")
+    suspend fun getValues(keys: List<String>): List<Entry>
+
+    @Transaction
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    suspend fun setValues(entries: List<Entry>)
+
+    @Transaction
+    @Query("DELETE FROM $TABLE_NAME WHERE `$COLUMN_KEY` in (:keys)")
+    suspend fun removeValues(keys: List<String>)
+
+    @Transaction
+    suspend fun mergeValues(entries: List<Entry>) {
+        val currentDbEntries = getValues(entries.map { it.key })
+        val newEntries = mutableListOf<Entry>()
+
+        entries.forEach { newEntry ->
+            val oldEntry = currentDbEntries.find { it.key == newEntry.key }
+            if (oldEntry?.value == null) {
+                newEntries.add(newEntry)
+            } else if (!oldEntry.value.isValidJson() || !newEntry.value.isValidJson()) {
+                newEntries.add(newEntry)
+            } else {
+                val newValue =
+                    JSONObject(oldEntry.value).mergeWith(JSONObject(newEntry.value)).toString()
+                newEntries.add(newEntry.copy(value = newValue))
+            }
+        }
+        setValues(newEntries)
+    }
+
+    @Transaction
+    @Query("SELECT `$COLUMN_KEY` FROM $TABLE_NAME")
+    suspend fun getKeys(): List<String>
+
+    @Transaction
+    @Query("DELETE FROM $TABLE_NAME")
+    suspend fun clear()
+}
+
+
+/**
+ * Previous version of AsyncStorage is violating the SQL standard (based on bug in SQLite),
+ * where PrimaryKey ('key' column) should never be null (https://www.sqlite.org/lang_createtable.html#the_primary_key).
+ * Because of that, we cannot reuse the old DB, because ROOM is guarded against that case (won't compile).
+ *
+ * In order to work around this, two steps are necessary:
+ *  - Room DB pre-population from the old database file (https://developer.android.com/training/data-storage/room/prepopulate#from-asset)
+ *  - Version migration, so that we can mark 'key' column as NOT-NULL
+ *
+ * This migration will happens only once, when developer enable this feature (when DB is still not created).
+ */
+@Suppress("ClassName")
+private object MIGRATION_TO_NEXT : Migration(1, 2) {
+    override fun migrate(database: SupportSQLiteDatabase) {
+        val oldTableName = "catalystLocalStorage" // from ReactDatabaseSupplier
+        database.execSQL("CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`${COLUMN_KEY}` TEXT NOT NULL, `${COLUMN_VALUE}` TEXT, PRIMARY KEY(`${COLUMN_KEY}`));")
+        // even if the old AsyncStorage has checks for not nullable keys
+        // make sure we don't copy any, to not fail migration
+        database.execSQL("DELETE FROM $oldTableName WHERE `${COLUMN_KEY}` IS NULL")
+        database.execSQL(
+            """
+            INSERT INTO $TABLE_NAME (`${COLUMN_KEY}`, `${COLUMN_VALUE}`)
+            SELECT `${COLUMN_KEY}`, `${COLUMN_VALUE}`
+            FROM $oldTableName;
+        """.trimIndent()
+        )
+        Log.e("AsyncStorage_Next", "Migration to Next storage completed.")
+    }
+}
+
+@Database(entities = [Entry::class], version = DATABASE_VERSION, exportSchema = false)
+internal abstract class StorageDb : RoomDatabase() {
+    abstract fun storage(): StorageDao
+
+    companion object {
+        private var instance: StorageDb? = null
+
+        fun getDatabase(context: Context): StorageDb {
+            var inst = instance
+            if (inst != null) {
+                return inst
+            }
+            synchronized(this) {
+                val oldDbFile = context.getDatabasePath("RKStorage")
+                val db = Room.databaseBuilder(
+                    context, StorageDb::class.java, DATABASE_NAME
+                )
+                if (oldDbFile.exists()) {
+                    // migrate data from old database, if it exists
+                    db.createFromFile(oldDbFile).addMigrations(MIGRATION_TO_NEXT)
+                }
+                inst = db.build()
+                instance = inst
+                return instance!!
+            }
+        }
+    }
+}
+
+interface AsyncStorageAccess {
+    suspend fun getValues(keys: List<String>): List<Entry>
+    suspend fun setValues(entries: List<Entry>)
+    suspend fun removeValues(keys: List<String>)
+    suspend fun getKeys(): List<String>
+    suspend fun clear()
+    suspend fun mergeValues(entries: List<Entry>)
+}
+
+class StorageSupplier internal constructor(db: StorageDb) : AsyncStorageAccess {
+    companion object {
+        fun getInstance(ctx: Context): AsyncStorageAccess {
+            return StorageSupplier(StorageDb.getDatabase(ctx))
+        }
+    }
+
+    private val access = db.storage()
+
+    override suspend fun getValues(keys: List<String>) = access.getValues(keys)
+    override suspend fun setValues(entries: List<Entry>) = access.setValues(entries)
+    override suspend fun removeValues(keys: List<String>) = access.removeValues(keys)
+    override suspend fun mergeValues(entries: List<Entry>) = access.mergeValues(entries)
+    override suspend fun getKeys() = access.getKeys()
+    override suspend fun clear() = access.clear()
+}

package/node_modules/@react-native-async-storage/async-storage/android/src/test/java/com/reactnativecommunity/asyncstorage/next/ArgumentHelpersTest.kt

@@ -0,0 +1,93 @@
+package com.reactnativecommunity.asyncstorage.next
+
+import com.facebook.react.bridge.JavaOnlyArray
+import com.facebook.react.bridge.ReadableArray
+import com.google.common.truth.Truth.assertThat
+import org.junit.Assert.assertThrows
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.BlockJUnit4ClassRunner
+
+@RunWith(BlockJUnit4ClassRunner::class)
+class ArgumentHelpersTest {
+
+    @Test
+    fun transformsArgumentsToEntryList() {
+        val args = JavaOnlyArray.of(
+            arrayListOf("key1", "value1"),
+            arrayListOf("key2", "value2"),
+            arrayListOf("key3", "value3")
+        )
+        assertThat(args.toEntryList()).isEqualTo(
+            listOf(
+                Entry("key1", "value1"),
+                Entry("key2", "value2"),
+                Entry("key3", "value3"),
+            )
+        )
+    }
+
+    @Test
+    fun transfersArgumentsToKeyList() {
+        val keyList = listOf("key1", "key2", "key3")
+        val args = keyList.toReadableArray()
+        assertThat(args.toKeyList()).isEqualTo(keyList)
+    }
+
+    @Test
+    fun throwsIfArgumentsNotValidFormat() {
+        val invalid = arrayListOf("invalid")
+        val args = JavaOnlyArray.of(invalid)
+        val error = assertThrows(AsyncStorageError::class.java) {
+            args.toEntryList()
+        }
+
+        assertThat(error is AsyncStorageError).isTrue()
+        assertThat(error).hasMessageThat()
+            .isEqualTo("Invalid key-value format. Expected a list of [key, value] list.")
+    }
+
+    @Test
+    fun throwsIfArgumentKeyIsNullOrNotString() {
+        val argsInvalidNull = JavaOnlyArray.of(arrayListOf(null, "invalid"))
+        val errorArgsInvalidNull = assertThrows(AsyncStorageError::class.java) {
+            argsInvalidNull.toEntryList()
+        }
+        assertThat(errorArgsInvalidNull is AsyncStorageError).isTrue()
+        assertThat(errorArgsInvalidNull).hasMessageThat().isEqualTo("Key cannot be null.")
+
+        val notStringArgs = JavaOnlyArray.of(arrayListOf(123, "invalid"))
+        val errorNotString = assertThrows(AsyncStorageError::class.java) {
+            notStringArgs.toEntryList()
+        }
+        assertThat(errorNotString is AsyncStorageError).isTrue()
+        assertThat(errorNotString).hasMessageThat()
+            .isEqualTo("Provided key is not string. Only strings are supported as storage key.")
+    }
+
+    @Test
+    fun throwsIfArgumentValueNotString() {
+        val invalidArgs = JavaOnlyArray.of(arrayListOf("my_key", 666))
+        val error = assertThrows(AsyncStorageError::class.java) {
+            invalidArgs.toEntryList()
+        }
+        assertThat(error is AsyncStorageError).isTrue()
+        assertThat(error).hasMessageThat()
+            .isEqualTo("Value for key \"my_key\" is not a string. Only strings are supported as a value.")
+    }
+}
+
+fun List<Any?>.toReadableArray(): ReadableArray {
+    val arr = JavaOnlyArray()
+    forEach {
+        when (it) {
+            null -> arr.pushNull()
+            is Boolean -> arr.pushBoolean(it)
+            is Double -> arr.pushDouble(it)
+            is Int -> arr.pushInt(it)
+            is String -> arr.pushString(it)
+            else -> throw NotImplementedError()
+        }
+    }
+    return arr
+}

package/node_modules/@react-native-async-storage/async-storage/android/src/test/java/com/reactnativecommunity/asyncstorage/next/StorageTest.kt

@@ -0,0 +1,141 @@
+package com.reactnativecommunity.asyncstorage.next
+
+import androidx.room.Room
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.platform.app.InstrumentationRegistry
+import com.google.common.truth.Truth.assertThat
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.runBlocking
+import org.json.JSONObject
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import kotlin.random.Random
+
+@ExperimentalCoroutinesApi
+@RunWith(AndroidJUnit4::class)
+class AsyncStorageAccessTest {
+    private lateinit var asyncStorage: AsyncStorageAccess
+    private lateinit var database: StorageDb
+
+    @Before
+    fun setup() {
+        database = Room.inMemoryDatabaseBuilder(
+            InstrumentationRegistry.getInstrumentation().context, StorageDb::class.java
+        ).allowMainThreadQueries().build()
+        asyncStorage = StorageSupplier(database)
+    }
+
+    @After
+    fun tearDown() {
+        database.close()
+    }
+
+    @Test
+    fun performsBasicGetSetRemoveOperations() = runBlocking {
+        val entriesCount = 10
+        val entries = createRandomEntries(entriesCount)
+        val keys = entries.map { it.key }
+        assertThat(asyncStorage.getValues(keys)).hasSize(0)
+        asyncStorage.setValues(entries)
+        assertThat(asyncStorage.getValues(keys)).hasSize(entriesCount)
+        val indicesToRemove = (1..4).map { Random.nextInt(0, entriesCount) }.distinct()
+        val toRemove = entries.filterIndexed { index, _ -> indicesToRemove.contains(index) }
+        asyncStorage.removeValues(toRemove.map { it.key })
+        val currentEntries = asyncStorage.getValues(keys)
+        assertThat(currentEntries).hasSize(entriesCount - toRemove.size)
+    }
+
+    @Test
+    fun readsAllKeysAndClearsDb() = runBlocking {
+        val entries = createRandomEntries(8)
+        val keys = entries.map { it.key }
+        asyncStorage.setValues(entries)
+        val dbKeys = asyncStorage.getKeys()
+        assertThat(dbKeys).isEqualTo(keys)
+        asyncStorage.clear()
+        assertThat(asyncStorage.getValues(keys)).hasSize(0)
+    }
+
+    @Test
+    fun mergesDeeplyTwoValues() = runBlocking {
+        val initialEntry = Entry("key", VALUE_INITIAL)
+        val overrideEntry = Entry("key", VALUE_OVERRIDES)
+        asyncStorage.setValues(listOf(initialEntry))
+        asyncStorage.mergeValues(listOf(overrideEntry))
+        val current = asyncStorage.getValues(listOf("key"))[0]
+        assertThat(current.value).isEqualTo(VALUE_MERGED)
+    }
+
+    @Test
+    fun updatesExistingValues() = runBlocking {
+        val key = "test_key"
+        val value = "test_value"
+        val entries = listOf(Entry(key, value))
+        assertThat(asyncStorage.getValues(listOf(key))).hasSize(0)
+        asyncStorage.setValues(entries)
+        assertThat(asyncStorage.getValues(listOf(key))).isEqualTo(entries)
+        val modifiedEntries = listOf(Entry(key, "updatedValue"))
+        asyncStorage.setValues(modifiedEntries)
+        assertThat(asyncStorage.getValues(listOf(key))).isEqualTo(modifiedEntries)
+    }
+
+
+    // Test Helpers
+    private fun createRandomEntries(count: Int = Random.nextInt(10)): List<Entry> {
+        val entries = mutableListOf<Entry>()
+        for (i in 0 until count) {
+            entries.add(Entry("key$i", "value$i"))
+        }
+        return entries
+    }
+
+    private val VALUE_INITIAL = JSONObject(
+        """
+    {
+       "key":"value",
+       "key2":"override",
+       "key3":{
+          "key4":"value4",
+          "key6":{
+             "key7":"value7",
+             "key8":"override"
+          }
+       }
+    }
+""".trimMargin()
+    ).toString()
+
+    private val VALUE_OVERRIDES = JSONObject(
+        """
+    {
+       "key2":"value2",
+       "key3":{
+          "key5":"value5",
+          "key6":{
+             "key8":"value8"
+          }
+       }
+    }
+"""
+    ).toString()
+
+
+    private val VALUE_MERGED = JSONObject(
+        """
+    {
+       "key":"value",
+       "key2":"value2",
+       "key3":{
+          "key4":"value4",
+          "key6":{
+             "key7":"value7",
+             "key8":"value8"
+          },
+          "key5":"value5"
+       }
+    }
+""".trimMargin()
+    ).toString()
+}

package/node_modules/@react-native-async-storage/async-storage/android/testresults.gradle

@@ -0,0 +1,38 @@
+
+// pretty print test results
+import org.gradle.api.tasks.testing.logging.TestExceptionFormat
+import org.gradle.api.tasks.testing.logging.TestLogEvent
+tasks.withType(Test) {
+    testLogging {
+
+        events TestLogEvent.FAILED,
+                TestLogEvent.PASSED,
+                TestLogEvent.SKIPPED,
+                TestLogEvent.STANDARD_OUT
+        exceptionFormat TestExceptionFormat.FULL
+        showExceptions true
+        showCauses true
+        showStackTraces true
+
+        debug {
+            events TestLogEvent.STARTED,
+                    TestLogEvent.FAILED,
+                    TestLogEvent.PASSED,
+                    TestLogEvent.SKIPPED,
+                    TestLogEvent.STANDARD_ERROR,
+                    TestLogEvent.STANDARD_OUT
+            exceptionFormat TestExceptionFormat.FULL
+        }
+        info.events = debug.events
+        info.exceptionFormat = debug.exceptionFormat
+
+        afterSuite { desc, result ->
+            if (!desc.parent) { // will match the outermost suite
+                def output = "Results: ${result.resultType} (${result.testCount} tests, ${result.successfulTestCount} passed, ${result.failedTestCount} failed, ${result.skippedTestCount} skipped)"
+                def startItem = '|  ', endItem = '  |'
+                def repeatLength = startItem.length() + output.length() + endItem.length()
+                println('\n' + ('-' * repeatLength) + '\n' + startItem + output + endItem + '\n' + ('-' * repeatLength))
+            }
+        }
+    }
+}