expo-native-sheet-emojis 2.0.3 → 2.0.4

package/android/src/main/java/expo/community/modules/emojisheet/EmojiData.kt

@@ -3,6 +3,8 @@ package expo.community.modules.emojisheet
 import android.content.Context
 import android.os.Build
 import org.json.JSONArray
+import java.text.Normalizer
+import java.util.Locale
 
 data class EmojiItem(
     val emoji: String,
@@ -10,7 +12,9 @@ data class EmojiItem(
     val v: String,
     val toneEnabled: Boolean,
     val keywords: List<String>,
-    val id: String
+    val id: String,
+    val normalizedName: String,
+    val normalizedKeywords: List<String>
 )
 
 data class EmojiCategory(
@@ -20,6 +24,8 @@ data class EmojiCategory(
 
 object EmojiData {
 
+    private val COMBINING_MARKS_REGEX = "\\p{Mn}+".toRegex()
+
     val categoryDisplayNames = mapOf(
         "frequently_used" to "Frequently Used",
         "smileys_emotion" to "Smileys & Emotion",
@@ -53,14 +59,17 @@ object EmojiData {
                 for (k in 0 until keywordsArray.length()) {
                     keywords.add(keywordsArray.getString(k))
                 }
+                val name = item.getString("name")
                 items.add(
                     EmojiItem(
                         emoji = item.getString("emoji"),
-                        name = item.getString("name"),
+                        name = name,
                         v = item.getString("v"),
                         toneEnabled = item.getBoolean("toneEnabled"),
                         keywords = keywords,
-                        id = item.getString("id")
+                        id = item.getString("id"),
+                        normalizedName = normalizeSearchText(name),
+                        normalizedKeywords = normalizedSearchKeywords(keywords)
                     )
                 )
             }
@@ -84,6 +93,27 @@ object EmojiData {
         }
     }
 
+    fun normalizeSearchText(text: String): String {
+        val normalized = Normalizer.normalize(text, Normalizer.Form.NFD)
+            .replace(COMBINING_MARKS_REGEX, "")
+        return normalized
+            .trim()
+            .lowercase(Locale.ROOT)
+    }
+
+    fun normalizedSearchVariants(text: String): Set<String> {
+        return setOf(normalizeSearchText(text)).filter { it.isNotBlank() }.toSet()
+    }
+
+    fun normalizedSearchKeywords(keywords: List<String>): List<String> {
+        return keywords
+            .asSequence()
+            .map(::normalizeSearchText)
+            .filter { it.isNotBlank() }
+            .distinct()
+            .toList()
+    }
+
     fun displayName(categoryTitle: String, customNames: Map<String, String>? = null): String {
         customNames?.get(categoryTitle)?.let { return it }
         return categoryDisplayNames[categoryTitle] ?: categoryTitle.replace("_", " ")

package/android/src/main/java/expo/community/modules/emojisheet/EmojiSheetContentView.kt

@@ -19,6 +19,7 @@ class EmojiSheetContentView(
 
     init {
         pickerView.layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT)
+        pickerView.setSheetExpanded(true)
         pickerView.onEmojiSelected = { data ->
             onEmojiSelected(data)
         }

package/android/src/main/java/expo/community/modules/emojisheet/EmojiSheetModule.kt

@@ -8,6 +8,7 @@ import android.view.View
 import android.view.ViewGroup
 import android.view.animation.AccelerateDecelerateInterpolator
 import android.view.WindowManager
+import android.view.inputmethod.InputMethodManager
 import androidx.core.view.ViewCompat
 import androidx.core.view.WindowCompat
 import androidx.core.view.WindowInsetsCompat
@@ -241,6 +242,7 @@ class EmojiSheetModule : Module() {
             }
         }
         pickerView.onPullDownAtTopDrag = { distance ->
+            dismissKeyboard()
             updateSheetDrag(bottomSheet, distance)
         }
         pickerView.onPullDownAtTopRelease = { distance, velocity ->
@@ -263,7 +265,11 @@ class EmojiSheetModule : Module() {
         }
 
         // Container
-        val halfExpandedRatio = snapPoints.firstOrNull()?.toFloat() ?: 0.55f
+        val halfExpandedRatio = (snapPoints.firstOrNull()?.toFloat() ?: 0.5f).coerceIn(0.05f, 1f)
+        val expandedRatio = maxOf(
+            halfExpandedRatio,
+            (snapPoints.getOrNull(1)?.toFloat() ?: 1f).coerceIn(0.05f, 1f)
+        )
         val minSheetHeight = (activity.resources.displayMetrics.heightPixels * halfExpandedRatio).toInt()
         val cornerRadius = 16 * density
         val container = LinearLayout(activity).apply {
@@ -288,16 +294,41 @@ class EmojiSheetModule : Module() {
 
         bottomSheet.setContentView(container)
 
-        ViewCompat.setOnApplyWindowInsetsListener(container) { view, insets ->
+        var wasKeyboardVisible = false
+        val applyDialogInsets: (WindowInsetsCompat) -> Unit = { insets ->
             val imeInsets = insets.getInsets(WindowInsetsCompat.Type.ime())
             val systemBarInsets = insets.getInsets(WindowInsetsCompat.Type.systemBars())
-            view.setPadding(
+            val navigationInsets = insets.getInsets(WindowInsetsCompat.Type.navigationBars())
+            val keyboardVisible = imeInsets.bottom > navigationInsets.bottom
+            container.setPadding(
                 systemBarInsets.left,
                 0,
                 systemBarInsets.right,
-                maxOf(imeInsets.bottom, systemBarInsets.bottom)
+                if (keyboardVisible) 0 else systemBarInsets.bottom
+            )
+            updateSheetForKeyboard(
+                bottomSheet,
+                pickerView,
+                minSheetHeight,
+                expandedRatio,
+                imeInsets.bottom,
+                navigationInsets.bottom
             )
-            WindowInsetsCompat.CONSUMED
+            if (keyboardVisible && bottomSheet.behavior.state != BottomSheetBehavior.STATE_EXPANDED) {
+                pickerView.setSheetExpansionInProgress(true)
+                bottomSheet.behavior.state = BottomSheetBehavior.STATE_EXPANDED
+            }
+            val shouldRestoreInitialSnap = wasKeyboardVisible &&
+                !keyboardVisible &&
+                bottomSheet.behavior.state != BottomSheetBehavior.STATE_HIDDEN
+            if (shouldRestoreInitialSnap) {
+                bottomSheet.behavior.state = BottomSheetBehavior.STATE_HALF_EXPANDED
+            }
+            wasKeyboardVisible = keyboardVisible
+        }
+        ViewCompat.setOnApplyWindowInsetsListener(container) { _, insets ->
+            applyDialogInsets(insets)
+            insets
         }
 
         // Strip ALL backgrounds from BottomSheet internals
@@ -305,22 +336,37 @@ class EmojiSheetModule : Module() {
             val d = dlg as BottomSheetDialog
             val bottomSheetInternal = d.findViewById<View>(com.google.android.material.R.id.design_bottom_sheet)
             bottomSheetContentView = bottomSheetInternal
+            d.findViewById<View>(com.google.android.material.R.id.container)?.fitsSystemWindows = false
+            d.findViewById<View>(com.google.android.material.R.id.coordinator)?.fitsSystemWindows = false
             bottomSheetInternal?.apply {
+                fitsSystemWindows = false
                 setBackgroundColor(Color.TRANSPARENT)
                 (parent as? View)?.setBackgroundColor(Color.TRANSPARENT)
+                ViewCompat.setOnApplyWindowInsetsListener(this) { _, insets ->
+                    applyDialogInsets(insets)
+                    insets
+                }
             }
+            bottomSheet.window?.let { window ->
+                WindowCompat.setDecorFitsSystemWindows(window, false)
+                window.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_NOTHING)
+            }
+            ViewCompat.requestApplyInsets(container)
+            bottomSheetInternal?.let { ViewCompat.requestApplyInsets(it) }
             pickerView.loadDataAsync()
             sendEvent("onSheetOpened", android.os.Bundle())
         }
 
         bottomSheet.window?.let { window ->
             WindowCompat.setDecorFitsSystemWindows(window, false)
+            window.setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_NOTHING)
         }
         bottomSheet.window?.setDimAmount(backdropOpacity)
 
         bottomSheet.behavior.apply {
             state = BottomSheetBehavior.STATE_HALF_EXPANDED
             this.halfExpandedRatio = halfExpandedRatio
+            expandedOffset = (activity.resources.displayMetrics.heightPixels * (1f - expandedRatio)).toInt()
             peekHeight = minSheetHeight
             isHideable = true
             skipCollapsed = false
@@ -328,6 +374,9 @@ class EmojiSheetModule : Module() {
             isDraggable = gestureEnabled
             addBottomSheetCallback(object : BottomSheetBehavior.BottomSheetCallback() {
                 override fun onStateChanged(bottomSheet: View, newState: Int) {
+                    if (newState == BottomSheetBehavior.STATE_DRAGGING) {
+                        dismissKeyboard()
+                    }
                     pickerView.setSheetExpanded(newState == BottomSheetBehavior.STATE_EXPANDED)
                     pickerView.setSheetExpansionInProgress(
                         newState == BottomSheetBehavior.STATE_DRAGGING ||
@@ -365,6 +414,64 @@ class EmojiSheetModule : Module() {
         dialog = null
     }
 
+    private fun dismissKeyboard() {
+        val activity = appContext.currentActivity ?: return
+        val focusedView = activity.currentFocus
+        val tokenView = focusedView
+            ?: bottomSheetContentView
+            ?: dialog?.window?.decorView
+            ?: return
+        val inputMethodManager = tokenView.context
+            .getSystemService(android.content.Context.INPUT_METHOD_SERVICE) as? InputMethodManager
+            ?: return
+
+        inputMethodManager.hideSoftInputFromWindow(tokenView.windowToken, 0)
+        focusedView?.clearFocus()
+    }
+
+    private fun updateSheetForKeyboard(
+        bottomSheet: BottomSheetDialog,
+        pickerView: EmojiSheetUIView,
+        minSheetHeight: Int,
+        expandedRatio: Float,
+        imeBottom: Int,
+        navigationBottom: Int
+    ) {
+        val keyboardHeight = if (imeBottom > navigationBottom) imeBottom else 0
+        val keyboardVisible = keyboardHeight > 0
+        val sheetView = bottomSheetContentView
+            ?: bottomSheet.findViewById<View>(com.google.android.material.R.id.design_bottom_sheet)
+
+        pickerView.setKeyboardDockedToSheet(keyboardVisible)
+
+        if (sheetView == null) return
+
+        val parentHeight = ((sheetView.parent as? View)?.height ?: 0)
+            .takeIf { it > 0 }
+            ?: sheetView.rootView.height.takeIf { it > 0 }
+            ?: sheetView.resources.displayMetrics.heightPixels
+        val desiredExpandedHeight = maxOf(1, (parentHeight * expandedRatio).toInt())
+        val targetHeight = if (keyboardVisible) {
+            minOf(maxOf(1, parentHeight - keyboardHeight), desiredExpandedHeight)
+        } else {
+            ViewGroup.LayoutParams.MATCH_PARENT
+        }
+        bottomSheet.behavior.expandedOffset = if (keyboardVisible) {
+            maxOf(0, parentHeight - keyboardHeight - targetHeight)
+        } else {
+            maxOf(0, parentHeight - desiredExpandedHeight)
+        }
+
+        val layoutParams = sheetView.layoutParams
+        if (layoutParams.height != targetHeight) {
+            layoutParams.height = targetHeight
+            sheetView.layoutParams = layoutParams
+        }
+        sheetView.translationY = 0f
+        bottomSheet.behavior.peekHeight = minSheetHeight
+        sheetView.requestLayout()
+    }
+
     private fun updateSheetDrag(bottomSheet: BottomSheetDialog, distance: Float) {
         val sheetView = bottomSheetContentView
             ?: bottomSheet.findViewById<View>(com.google.android.material.R.id.design_bottom_sheet)

package/android/src/main/java/expo/community/modules/emojisheet/EmojiSheetUIView.kt

@@ -10,6 +10,8 @@ import android.view.VelocityTracker
 import android.widget.FrameLayout
 import android.widget.LinearLayout
 import android.widget.TextView
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
 import androidx.recyclerview.widget.GridLayoutManager
 import androidx.recyclerview.widget.RecyclerView
 import kotlinx.coroutines.CoroutineScope
@@ -23,8 +25,6 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
 import kotlinx.coroutines.withContext
-import java.text.Normalizer
-import java.util.Locale
 
 class EmojiSheetUIView(context: Context) : LinearLayout(context) {
 
@@ -33,7 +33,6 @@ class EmojiSheetUIView(context: Context) : LinearLayout(context) {
         private const val FREQ_COUNT_SUFFIX = "_count"
         private const val FREQ_DAY_SUFFIX = "_day"
         private const val FREQ_TIME_SUFFIX = "_time"
-        private val COMBINING_MARKS_REGEX = "\\p{Mn}+".toRegex()
         private val cacheScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
         private val cacheMutex = Mutex()
         @Volatile
@@ -75,14 +74,17 @@ class EmojiSheetUIView(context: Context) : LinearLayout(context) {
                         val arr = obj.getJSONArray(key)
                         val keywords = merged.getOrPut(key) { mutableListOf() }
                         for (i in 0 until arr.length()) {
-                            keywords.add(arr.getString(i))
+                            val normalizedKeyword = EmojiData.normalizeSearchText(arr.getString(i))
+                            if (normalizedKeyword.isNotBlank()) {
+                                keywords.add(normalizedKeyword)
+                            }
                         }
                     }
                 }
             } catch (e: Exception) {
                 // Fallback or empty
             }
-            return merged
+            return merged.mapValues { it.value.distinct() }
         }
     }
 
@@ -114,6 +116,7 @@ class EmojiSheetUIView(context: Context) : LinearLayout(context) {
     private var currentTheme = EmojiSheetTheme.light
     private var allCategories: List<EmojiCategory> = emptyList()
     private var allCategoryKeys: List<String> = emptyList()
+    // Values are normalized once at load time so search scoring only compares strings.
     private var localizedKeywords: Map<String, List<String>> = emptyMap()
 
     private val searchBar: EmojiSearchBar
@@ -139,6 +142,10 @@ class EmojiSheetUIView(context: Context) : LinearLayout(context) {
     private var velocityTracker: VelocityTracker? = null
     private var topPullStartY: Float? = null
     private val topPullActivationThresholdPx = 24f * context.resources.displayMetrics.density
+    private val keyboardResultBottomGapPx = (16f * context.resources.displayMetrics.density).toInt()
+    private var baseRecyclerBottomPadding = 0
+    private var keyboardRecyclerBottomPadding = 0
+    private var usesDockedSheetKeyboardInsets = false
     private val viewScope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
     private var loadJob: Job? = null
     private var searchJob: Job? = null
@@ -238,7 +245,12 @@ class EmojiSheetUIView(context: Context) : LinearLayout(context) {
 
                         val deltaY = e.y - initialTouchY
                         val isAtTop = !rv.canScrollVertically(-1)
-                        if (!isSheetExpanded && deltaY < -touchSlop && !didTriggerExpandForCurrentDrag) {
+                        if (
+                            !isSheetExpanded &&
+                            onScrollIntentUp != null &&
+                            deltaY < -touchSlop &&
+                            !didTriggerExpandForCurrentDrag
+                        ) {
                             didTriggerExpandForCurrentDrag = true
                             isSheetExpansionInProgress = true
                             rv.stopScroll()
@@ -284,7 +296,7 @@ class EmojiSheetUIView(context: Context) : LinearLayout(context) {
             }
 
             override fun onScrolled(rv: RecyclerView, dx: Int, dy: Int) {
-                if (!isSheetExpanded) {
+                if (!isSheetExpanded && onScrollIntentUp != null) {
                     rv.stopScroll()
                     return
                 }
@@ -330,6 +342,14 @@ class EmojiSheetUIView(context: Context) : LinearLayout(context) {
         }
         addView(contentFrame)
 
+        ViewCompat.setOnApplyWindowInsetsListener(this) { _, insets ->
+            setKeyboardBottomInset(
+                imeBottom = insets.getInsets(WindowInsetsCompat.Type.ime()).bottom,
+                navigationBottom = insets.getInsets(WindowInsetsCompat.Type.navigationBars()).bottom
+            )
+            insets
+        }
+
         applyTheme(currentTheme)
         applyLayoutDirection()
     }
@@ -348,6 +368,28 @@ class EmojiSheetUIView(context: Context) : LinearLayout(context) {
         }
     }
 
+    fun setKeyboardBottomInset(imeBottom: Int, navigationBottom: Int) {
+        if (usesDockedSheetKeyboardInsets) return
+
+        val keyboardOnlyBottom = maxOf(0, imeBottom - navigationBottom)
+        setKeyboardRecyclerBottomPadding(
+            if (keyboardOnlyBottom > 0) keyboardOnlyBottom + keyboardResultBottomGapPx else 0
+        )
+    }
+
+    fun setKeyboardDockedToSheet(keyboardVisible: Boolean) {
+        usesDockedSheetKeyboardInsets = true
+        setKeyboardRecyclerBottomPadding(
+            if (keyboardVisible) keyboardResultBottomGapPx else 0
+        )
+    }
+
+    private fun setKeyboardRecyclerBottomPadding(bottomPadding: Int) {
+        if (keyboardRecyclerBottomPadding == bottomPadding) return
+        keyboardRecyclerBottomPadding = bottomPadding
+        updateRecyclerBottomPadding()
+    }
+
     /** Call after setting configurable properties but before loadDataAsync to apply layout changes. */
     fun applyConfiguration() {
         // Update grid adapter settings
@@ -419,18 +461,32 @@ class EmojiSheetUIView(context: Context) : LinearLayout(context) {
 
             // Bottom padding so grid content scrolls above the floating bar
             val totalBarSpace = stripHeight + bottomInset * 2
-            recyclerView.setPadding(
-                recyclerView.paddingLeft,
-                recyclerView.paddingTop,
-                recyclerView.paddingRight,
-                totalBarSpace
-            )
-            recyclerView.clipToPadding = false
+            baseRecyclerBottomPadding = totalBarSpace
+            updateRecyclerBottomPadding()
 
             addView(wrapperFrame)
+        } else {
+            baseRecyclerBottomPadding = 0
+            updateRecyclerBottomPadding()
         }
     }
 
+    private fun setGridItems(items: List<EmojiGridAdapter.ListItem>, sectionPositions: List<Int>) {
+        gridAdapter.setItems(items, sectionPositions)
+        stickyHeaderDecoration.invalidateCache()
+        recyclerView.invalidateItemDecorations()
+    }
+
+    private fun updateRecyclerBottomPadding() {
+        recyclerView.setPadding(
+            recyclerView.paddingLeft,
+            recyclerView.paddingTop,
+            recyclerView.paddingRight,
+            baseRecyclerBottomPadding + keyboardRecyclerBottomPadding
+        )
+        recyclerView.clipToPadding = false
+    }
+
     var searchPlaceholder: String? = null
         set(value) { field = value; if (value != null) searchBar.setHint(value) }
     var noResultsText: String? = null
@@ -549,8 +605,7 @@ class EmojiSheetUIView(context: Context) : LinearLayout(context) {
             }
         }
 
-        gridAdapter.setItems(items, sectionPositions)
-        stickyHeaderDecoration.invalidateCache()
+        setGridItems(items, sectionPositions)
 
         // Rebuild category keys in case frequently_used changed
         val newKeys = buildCategoryKeys()
@@ -625,6 +680,10 @@ class EmojiSheetUIView(context: Context) : LinearLayout(context) {
         isSearchActive = true
         categoryStrip.visibility = View.GONE
         bottomPillContainer?.visibility = View.GONE
+        emptyStateLabel.visibility = View.GONE
+        recyclerView.visibility = View.VISIBLE
+        setGridItems(emptyList(), emptyList())
+        recyclerView.scrollToPosition(0)
 
         val generation = ++searchGeneration
         val categories = allCategories
@@ -633,7 +692,7 @@ class EmojiSheetUIView(context: Context) : LinearLayout(context) {
         val exclude = excludeEmojis
         searchJob = viewScope.launch {
             val matchedItems = withContext(Dispatchers.Default) {
-                val normalizedQueryVariants = normalizedSearchVariants(trimmedQuery)
+                val normalizedQueryVariants = EmojiData.normalizedSearchVariants(trimmedQuery)
                 val scored = mutableListOf<Pair<EmojiGridAdapter.ListItem.Emoji, Int>>()
 
                 for (cat in categories) {
@@ -671,7 +730,7 @@ class EmojiSheetUIView(context: Context) : LinearLayout(context) {
 
             emptyStateLabel.visibility = if (matchedItems.isNotEmpty()) View.GONE else View.VISIBLE
             recyclerView.visibility = if (matchedItems.isNotEmpty()) View.VISIBLE else View.GONE
-            gridAdapter.setItems(results, sectionPositions)
+            setGridItems(results, sectionPositions)
             recyclerView.scrollToPosition(0)
         }
     }
@@ -782,22 +841,6 @@ class EmojiSheetUIView(context: Context) : LinearLayout(context) {
         return emoji.filter { it.code != 0xFE0E && it.code != 0xFE0F }
     }
 
-    private fun normalizeSearchText(text: String): String {
-        val normalized = Normalizer.normalize(text, Normalizer.Form.NFD)
-            .replace(COMBINING_MARKS_REGEX, "")
-        return normalized
-            .trim()
-            .lowercase(Locale.ROOT)
-    }
-
-    private fun normalizedSearchVariants(text: String): Set<String> {
-        return setOf(normalizeSearchText(text)).filter { it.isNotBlank() }.toSet()
-    }
-
-    private fun matchesSearch(normalizedText: String, queryVariants: Set<String>): Boolean {
-        return queryVariants.any { normalizedText.contains(it) }
-    }
-
     // Relevance scoring for search results:
     // 100 = exact name match, 90 = name starts with, 80 = exact keyword,
     // 70 = keyword starts with, 50 = name contains, 30 = keyword contains,
@@ -807,18 +850,15 @@ class EmojiSheetUIView(context: Context) : LinearLayout(context) {
         queryVariants: Set<String>,
         localizedKeywords: Map<String, List<String>>
     ): Int {
-        val nameNorm = normalizeSearchText(emoji.name)
-
         // Check name
         for (variant in queryVariants) {
-            if (nameNorm == variant) return 100
-            if (nameNorm.startsWith(variant)) return 90
+            if (emoji.normalizedName == variant) return 100
+            if (emoji.normalizedName.startsWith(variant)) return 90
         }
 
         // Check built-in keywords
         var bestScore = 0
-        for (kw in emoji.keywords) {
-            val kwNorm = normalizeSearchText(kw)
+        for (kwNorm in emoji.normalizedKeywords) {
             for (variant in queryVariants) {
                 if (kwNorm == variant) bestScore = maxOf(bestScore, 80)
                 else if (kwNorm.startsWith(variant)) bestScore = maxOf(bestScore, 70)
@@ -830,7 +870,7 @@ class EmojiSheetUIView(context: Context) : LinearLayout(context) {
         // Check name contains (lower priority than keyword exact/startsWith)
         if (bestScore < 50) {
             for (variant in queryVariants) {
-                if (nameNorm.contains(variant)) bestScore = maxOf(bestScore, 50)
+                if (emoji.normalizedName.contains(variant)) bestScore = maxOf(bestScore, 50)
             }
         }
 
@@ -841,7 +881,7 @@ class EmojiSheetUIView(context: Context) : LinearLayout(context) {
             ?: localizedKeywords[stripVariationSelectors(emoji.emoji)]
         if (localKw != null) {
             for (kw in localKw) {
-                if (queryVariants.any { normalizeSearchText(kw).contains(it) }) return 10
+                if (queryVariants.any { kw.contains(it) }) return 10
             }
         }
 
@@ -863,4 +903,9 @@ class EmojiSheetUIView(context: Context) : LinearLayout(context) {
         searchJob?.cancel()
         viewScope.cancel()
     }
+
+    override fun onAttachedToWindow() {
+        super.onAttachedToWindow()
+        ViewCompat.requestApplyInsets(this)
+    }
 }

package/ios/EmojiGridView.swift

@@ -120,7 +120,11 @@ class EmojiGridView: UIView, UICollectionViewDataSource, UICollectionViewDelegat
     func updateSections(_ newSections: [EmojiSection], categoryNames: [String: String]) {
         self.sections = newSections
         self.categoryNames = categoryNames
-        collectionView.reloadData()
+        UIView.performWithoutAnimation {
+            collectionView.collectionViewLayout.invalidateLayout()
+            collectionView.reloadData()
+            collectionView.layoutIfNeeded()
+        }
     }
 
     func applyTheme(_ theme: EmojiSheetTheme) {

package/ios/EmojiSheetContentView.swift

@@ -10,6 +10,9 @@ struct EmojiItem: Sendable {
     let toneEnabled: Bool
     let keywords: [String]
     let id: String
+    let normalizedName: String
+    let normalizedNameVariants: [String]
+    let normalizedKeywords: [String]
 }
 
 struct EmojiSection: Sendable {

package/ios/EmojiSheetModule.podspec

@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
   s.name           = 'EmojiSheetModule'
-  s.version        = '2.0.3'
+  s.version        = '2.0.4'
   s.summary        = 'Native emoji picker bottom sheet for React Native'
   s.description    = 'A fully native iOS/Android emoji picker presented in a bottom sheet with search, skin tones, and theming support.'
   s.author         = ''

package/ios/EmojiSheetModule.swift

@@ -217,7 +217,10 @@ public class EmojiSheetModule: Module {
             sheetBackgroundColor: bgColor,
             theme: customTheme
         )
-        sheetVC.mediumDetentRatio = CGFloat(snapPoints.first ?? 0.5)
+        let mediumRatio = min(max(CGFloat(snapPoints.first ?? 0.5), 0.05), 1)
+        let largeRatio = min(max(CGFloat(snapPoints.dropFirst().first ?? 1.0), mediumRatio), 1)
+        sheetVC.mediumDetentRatio = mediumRatio
+        sheetVC.largeDetentRatio = largeRatio
         sheetVC.gestureEnabled = gestureEnabled
         sheetVC.embedPickerView(pickerView)
         sheetVC.onAppear = { [weak self] in
@@ -329,6 +332,7 @@ private final class SheetViewController: UIViewController, UIGestureRecognizerDe
     var onAppear: (() -> Void)?
     var onDismiss: (() -> Void)?
     var mediumDetentRatio: CGFloat = 0.5
+    var largeDetentRatio: CGFloat = 1.0
     var gestureEnabled: Bool = true
 
     private let backdropView = UIView()
@@ -387,7 +391,7 @@ private final class SheetViewController: UIViewController, UIGestureRecognizerDe
             options: [.curveEaseOut]
         ) {
             self.backdropView.alpha = Layout.backdropAlpha
-            self.sheetContainerView.transform = self.transform(for: self.currentDetent)
+            self.applyDetentLayout(self.currentDetent)
         } completion: { [weak self] _ in
             self?.onAppear?()
         }
@@ -404,7 +408,7 @@ private final class SheetViewController: UIViewController, UIGestureRecognizerDe
         }
 
         guard hasPresented, !isAnimatingDismissal else { return }
-        sheetContainerView.transform = transform(for: currentDetent)
+        applyDetentLayout(currentDetent)
     }
 
     func embedPickerView(_ embeddedView: UIView) {
@@ -454,8 +458,9 @@ private final class SheetViewController: UIViewController, UIGestureRecognizerDe
         currentDetent = detent
 
         let updates = {
-            self.sheetContainerView.transform = self.transform(for: detent)
+            self.applyDetentLayout(detent)
             self.backdropView.alpha = Layout.backdropAlpha
+            self.view.layoutIfNeeded()
         }
 
         if animated {
@@ -497,12 +502,13 @@ private final class SheetViewController: UIViewController, UIGestureRecognizerDe
             .union(.beginFromCurrentState)
 
         let overlap = keyboardOverlap(for: endFrame)
+        let wasKeyboardVisible = keyboardOverlap > 0
         let targetDetent: Detent
 
-        if overlap > 0, isSearchFocused {
+        if wasKeyboardVisible, overlap == 0 {
+            targetDetent = .medium
+        } else if overlap > 0, isSearchFocused {
             targetDetent = .large
-        } else if overlap == 0, !isSearchFocused, let previousDetent = detentBeforeSearchFocus {
-            targetDetent = previousDetent
         } else {
             targetDetent = currentDetent
         }
@@ -513,13 +519,13 @@ private final class SheetViewController: UIViewController, UIGestureRecognizerDe
             options: animationOptions
         ) {
             self.keyboardOverlap = overlap
-            self.sheetBottomConstraint?.constant = -overlap
-            self.sheetContainerView.transform = self.transform(for: targetDetent)
+            self.applyDetentLayout(targetDetent, keyboardOverlap: overlap)
             self.backdropView.alpha = Layout.backdropAlpha
             self.view.layoutIfNeeded()
         } completion: { _ in
             self.currentDetent = targetDetent
-            if overlap == 0, !self.isSearchFocused {
+            if overlap == 0 {
+                self.isSearchFocused = false
                 self.detentBeforeSearchFocus = nil
             }
         }
@@ -552,6 +558,8 @@ private final class SheetViewController: UIViewController, UIGestureRecognizerDe
 
     private func updateSheetDrag(_ distance: CGFloat) {
         guard !isAnimatingDismissal, currentDetent == .large else { return }
+        dismissKeyboardForSheetDrag()
+
         let adjustedDistance = max(0, distance * 0.7)
         sheetContainerView.layer.removeAllAnimations()
         sheetContainerView.transform = CGAffineTransform(translationX: 0, y: adjustedDistance)
@@ -579,8 +587,9 @@ private final class SheetViewController: UIViewController, UIGestureRecognizerDe
             initialSpringVelocity: 0.1,
             options: [.curveEaseOut]
         ) {
-            self.sheetContainerView.transform = self.transform(for: .large)
+            self.applyDetentLayout(.large)
             self.backdropView.alpha = Layout.backdropAlpha
+            self.view.layoutIfNeeded()
         }
     }
 
@@ -692,6 +701,9 @@ private final class SheetViewController: UIViewController, UIGestureRecognizerDe
 
         switch gesture.state {
         case .changed:
+            if gesture.translation(in: view).y > 0 {
+                dismissKeyboardForSheetDrag()
+            }
             sheetContainerView.transform = CGAffineTransform(translationX: 0, y: translationY)
             backdropView.alpha = Layout.backdropAlpha * (1 - dismissProgress)
         case .ended, .cancelled:
@@ -727,29 +739,61 @@ private final class SheetViewController: UIViewController, UIGestureRecognizerDe
         }
     }
 
+    private func dismissKeyboardForSheetDrag() {
+        view.endEditing(true)
+    }
+
     private var dismissalTranslation: CGFloat {
         sheetContainerView.bounds.height + view.safeAreaInsets.bottom + 24
     }
 
-    private func transform(for detent: Detent) -> CGAffineTransform {
-        CGAffineTransform(translationX: 0, y: translation(for: detent))
+    private func applyDetentLayout(_ detent: Detent, keyboardOverlap overlap: CGFloat? = nil) {
+        let overlap = overlap ?? keyboardOverlap
+        sheetBottomConstraint?.constant = bottomConstraintConstant(for: detent, keyboardOverlap: overlap)
+        sheetContainerView.transform = transform(for: detent, keyboardOverlap: overlap)
+    }
+
+    private func transform(for detent: Detent, keyboardOverlap overlap: CGFloat? = nil) -> CGAffineTransform {
+        CGAffineTransform(translationX: 0, y: translation(for: detent, keyboardOverlap: overlap))
     }
 
     private func transformForDismissal() -> CGAffineTransform {
         CGAffineTransform(translationX: 0, y: dismissalTranslation)
     }
 
-    private func translation(for detent: Detent) -> CGFloat {
+    private func bottomConstraintConstant(for detent: Detent, keyboardOverlap overlap: CGFloat? = nil) -> CGFloat {
+        let overlap = overlap ?? keyboardOverlap
+        guard overlap > 0 else { return 0 }
+        return -overlap - translation(for: detent, keyboardOverlap: overlap)
+    }
+
+    private func translation(for detent: Detent, keyboardOverlap overlap: CGFloat? = nil) -> CGFloat {
+        let fullHeight = max(0, view.bounds.height - view.safeAreaInsets.top - Layout.sheetTopInset)
+        let availableHeight = max(0, fullHeight - (overlap ?? keyboardOverlap))
+        let visibleHeight = visibleHeight(for: detent, availableHeight: availableHeight, fullHeight: fullHeight)
+        return max(0, availableHeight - visibleHeight)
+    }
+
+    private func visibleHeight(for detent: Detent, availableHeight: CGFloat, fullHeight: CGFloat) -> CGFloat {
         switch detent {
         case .large:
-            return 0
-        case .medium:
-            let containerHeight = max(sheetContainerView.bounds.height, 0)
-            let visibleHeight = max(
+            let mediumVisibleHeight = max(
                 Layout.minimumMediumVisibleHeight,
-                containerHeight * mediumDetentRatio
+                fullHeight * mediumDetentRatio
+            )
+            return min(
+                availableHeight,
+                max(mediumVisibleHeight, fullHeight * largeDetentRatio)
+            )
+        case .medium:
+            let visibleHeight = min(
+                availableHeight,
+                max(
+                    Layout.minimumMediumVisibleHeight,
+                    fullHeight * mediumDetentRatio
+                )
             )
-            return max(0, containerHeight - min(visibleHeight, containerHeight))
+            return max(0, visibleHeight)
         }
     }
 }

package/ios/EmojiSheetUIView.swift

@@ -91,6 +91,7 @@ class EmojiSheetUIView: UIView,
         static let floatingBarHorizontalInset: CGFloat = 16
         static let floatingBarBottomInset: CGFloat = 8
         static let floatingBarCornerRadius: CGFloat = 22
+        static let keyboardBottomSpacing: CGFloat = 16
     }
 
     weak var delegate: EmojiSheetUIViewDelegate?
@@ -141,6 +142,7 @@ class EmojiSheetUIView: UIView,
     private var allSections: [EmojiSection] = []
     private var filteredSections: [EmojiSection] = []
     private var frequentlyUsedSection: EmojiSection?
+    // Values are normalized once at load time so search scoring only compares strings.
     private var localizedKeywords: [String: [String]] = [:]
     private var currentSearchText: String?
     private var loadTask: Task<Void, Never>?
@@ -148,6 +150,8 @@ class EmojiSheetUIView: UIView,
     // Search work is cancellable. The generation counter remains as a lightweight
     // secondary guard so stale results never apply after a newer query wins.
     private var searchGeneration: Int = 0
+    private var baseGridBottomInset: CGFloat = 0
+    private var keyboardGridBottomInset: CGFloat = 0
 
     private let searchBar = EmojiSearchBar()
     private let categoryStrip = EmojiCategoryStrip()
@@ -181,6 +185,7 @@ class EmojiSheetUIView: UIView,
         "symbols": "Symbols",
         "flags": "Flags",
         "frequently_used": "Frequently Used",
+        "search_results": "Search Results",
     ]
 
     // MARK: - Init
@@ -197,6 +202,7 @@ class EmojiSheetUIView: UIView,
     deinit {
         loadTask?.cancel()
         searchTask?.cancel()
+        NotificationCenter.default.removeObserver(self)
     }
 
     // MARK: - Setup
@@ -221,6 +227,7 @@ class EmojiSheetUIView: UIView,
         categoryStrip.delegate = self
         gridView.delegate = self
 
+        registerKeyboardNotifications()
         configureLayout()
         applyLayoutDirection()
     }
@@ -353,7 +360,8 @@ class EmojiSheetUIView: UIView,
             // Bottom content inset so grid content scrolls above the floating bar
             let floatingBarTotalHeight = LayoutConstants.categoryStripHeight
                 + LayoutConstants.floatingBarBottomInset * 2
-            gridView.setBottomContentInset(floatingBarTotalHeight)
+            baseGridBottomInset = floatingBarTotalHeight
+            applyGridBottomInset()
 
         } else {
             // Top bar mode (default)
@@ -364,7 +372,8 @@ class EmojiSheetUIView: UIView,
                 categoryStrip.translatesAutoresizingMaskIntoConstraints = false
             }
 
-            gridView.setBottomContentInset(0)
+            baseGridBottomInset = 0
+            applyGridBottomInset()
 
             searchBarTopConstraint = searchBar.topAnchor.constraint(
                 equalTo: topAnchor, constant: LayoutConstants.searchBarTopSpacing)
@@ -399,6 +408,58 @@ class EmojiSheetUIView: UIView,
         isLayoutConfigured = true
     }
 
+    private func registerKeyboardNotifications() {
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(keyboardWillChangeFrame(_:)),
+            name: UIResponder.keyboardWillChangeFrameNotification,
+            object: nil
+        )
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(keyboardWillHide(_:)),
+            name: UIResponder.keyboardWillHideNotification,
+            object: nil
+        )
+    }
+
+    @objc private func keyboardWillChangeFrame(_ notification: Notification) {
+        guard
+            window != nil,
+            let keyboardFrame = notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect
+        else { return }
+
+        let keyboardFrameInView = convert(keyboardFrame, from: nil)
+        let overlap = bounds.intersection(keyboardFrameInView).height
+        keyboardGridBottomInset = overlap > 0
+            ? max(0, overlap - safeAreaInsets.bottom) + LayoutConstants.keyboardBottomSpacing
+            : 0
+        applyGridBottomInset(animatedWith: notification)
+    }
+
+    @objc private func keyboardWillHide(_ notification: Notification) {
+        keyboardGridBottomInset = 0
+        applyGridBottomInset(animatedWith: notification)
+    }
+
+    private func applyGridBottomInset(animatedWith notification: Notification? = nil) {
+        let inset = baseGridBottomInset + keyboardGridBottomInset
+        guard
+            let notification,
+            let duration = notification.userInfo?[UIResponder.keyboardAnimationDurationUserInfoKey] as? TimeInterval,
+            let curve = notification.userInfo?[UIResponder.keyboardAnimationCurveUserInfoKey] as? Int
+        else {
+            gridView.setBottomContentInset(inset)
+            return
+        }
+
+        let options = UIView.AnimationOptions(rawValue: UInt(curve << 16)).union(.beginFromCurrentState)
+        UIView.animate(withDuration: duration, delay: 0, options: options) {
+            self.gridView.setBottomContentInset(inset)
+            self.layoutIfNeeded()
+        }
+    }
+
     // MARK: - Data Loading (cached across instances)
 
     private static let dataCache = EmojiDataCache.shared
@@ -443,7 +504,7 @@ class EmojiSheetUIView: UIView,
             }
         }
 
-        return merged
+        return merged.mapValues { Array(Set($0)) }
     }
 
     nonisolated private static func mergeKeywords(from url: URL, into merged: inout [String: [String]]) {
@@ -451,11 +512,14 @@ class EmojiSheetUIView: UIView,
               let dict = try? JSONSerialization.jsonObject(with: data) as? [String: [String]]
         else { return }
         for (key, value) in dict {
+            let normalized = normalizedSearchKeywords(value)
+            guard !normalized.isEmpty else { continue }
+
             if var existing = merged[key] {
-                existing.append(contentsOf: value)
+                existing.append(contentsOf: normalized)
                 merged[key] = existing
             } else {
-                merged[key] = value
+                merged[key] = normalized
             }
         }
     }
@@ -525,7 +589,17 @@ class EmojiSheetUIView: UIView,
                 }
                 let emojiVersion = Double(v) ?? 0
                 guard emojiVersion <= maxVersion else { return nil }
-                return EmojiItem(emoji: emoji, name: name, version: v, toneEnabled: toneEnabled, keywords: keywords, id: id)
+                return EmojiItem(
+                    emoji: emoji,
+                    name: name,
+                    version: v,
+                    toneEnabled: toneEnabled,
+                    keywords: keywords,
+                    id: id,
+                    normalizedName: normalizeSearchText(name),
+                    normalizedNameVariants: normalizedSearchVariants(name),
+                    normalizedKeywords: normalizedSearchKeywords(keywords)
+                )
             }
             return EmojiSection(title: title, data: emojis)
         }
@@ -576,6 +650,12 @@ class EmojiSheetUIView: UIView,
         }
 
         categoryStrip.setSearchActive(true)
+        emptyStateLabel.isHidden = true
+        gridView.isHidden = false
+        filteredSections = []
+        gridView.updateSections([], categoryNames: mergedCategoryNames)
+        gridView.scrollToTop()
+
         searchGeneration += 1
         let generation = searchGeneration
         let sections = filteredAllSections
@@ -635,18 +715,15 @@ class EmojiSheetUIView: UIView,
         searchVariants: [String],
         localizedKeywords: [String: [String]]
     ) -> Int {
-        let nameNorm = normalizeSearchText(item.name)
-
         // Check name
         for variant in searchVariants {
-            if nameNorm == variant { return 100 }
-            if nameNorm.hasPrefix(variant) { return 90 }
+            if item.normalizedName == variant { return 100 }
+            if item.normalizedName.hasPrefix(variant) { return 90 }
         }
 
         // Check built-in keywords
         var bestScore = 0
-        for kw in item.keywords {
-            let kwNorm = normalizeSearchText(kw)
+        for kwNorm in item.normalizedKeywords {
             for variant in searchVariants {
                 if kwNorm == variant { bestScore = max(bestScore, 80) }
                 else if kwNorm.hasPrefix(variant) { bestScore = max(bestScore, 70) }
@@ -658,7 +735,7 @@ class EmojiSheetUIView: UIView,
         // Check name contains (lower priority than keyword exact/startsWith)
         if bestScore < 50 {
             for variant in searchVariants {
-                if nameNorm.contains(variant) { bestScore = max(bestScore, 50) }
+                if item.normalizedName.contains(variant) { bestScore = max(bestScore, 50) }
             }
         }
 
@@ -666,14 +743,12 @@ class EmojiSheetUIView: UIView,
 
         // Check localized keywords
         let localKw = Self.localizedKeywordsForEmoji(item.emoji, in: localizedKeywords)
-        for kw in localKw {
-            let kwNorm = normalizeSearchText(kw)
+        for kwNorm in localKw {
             if searchVariants.contains(where: { kwNorm.contains($0) }) { return 10 }
         }
 
         // Transliteration fallback for non-Latin scripts
-        let nameVariants = normalizedSearchVariants(item.name)
-        for nameVariant in nameVariants where nameVariant != nameNorm {
+        for nameVariant in item.normalizedNameVariants where nameVariant != item.normalizedName {
             if searchVariants.contains(where: { nameVariant.contains($0) }) { return 5 }
         }
 
@@ -758,6 +833,16 @@ class EmojiSheetUIView: UIView,
         )
     }
 
+    nonisolated private static func normalizedSearchKeywords(_ keywords: [String]) -> [String] {
+        Array(
+            Set(
+                keywords
+                    .map(normalizeSearchText)
+                    .filter { !$0.isEmpty }
+            )
+        )
+    }
+
     // MARK: - Theme
 
     func updateTheme(_ theme: String) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-native-sheet-emojis",
-  "version": "2.0.3",
+  "version": "2.0.4",
   "description": "A fully native emoji picker bottom sheet for React Native. Built with Swift and Kotlin for maximum performance. Features search with multilingual keywords, skin tones, frequently used tracking, theming, and configurable layout.",
   "main": "lib/commonjs/index.js",
   "module": "lib/module/index.js",