@synonymdev/react-native-toast 0.1.0

package/API.md

@@ -0,0 +1,210 @@
+# API
+
+## `showToast(options)`
+
+Displays a native toast notification.
+
+```ts
+import { showToast } from '@synonymdev/react-native-toast';
+
+showToast({
+	type: 'success',
+	title: 'Saved',
+	description: 'Your changes are ready.',
+});
+```
+
+## Toast Options
+
+```ts
+type ToastOptions = {
+	type: 'success' | 'info' | 'warning' | 'error';
+	title: string;
+	description?: string;
+	autoHide?: boolean;
+	dismissible?: boolean;
+	haptics?: boolean;
+	durationMs?: number;
+	style?: NativeToastStyle;
+};
+```
+
+| Option | Default | Description |
+| --- | --- | --- |
+| `type` | Required | Visual variant for the toast. |
+| `title` | Required | Primary toast text. |
+| `description` | `undefined` | Secondary toast text. |
+| `autoHide` | `true` | Whether the toast dismisses itself after `durationMs`. |
+| `dismissible` | `true` | Whether the toast can be dismissed with an upward swipe. |
+| `haptics` | `false` | Whether to trigger native haptic feedback when the toast is shown. |
+| `durationMs` | `4000` | Auto-hide delay in milliseconds. Native implementations enforce a minimum visible duration. |
+| `style` | `undefined` | Native style overrides. |
+
+Set `autoHide: false` to keep a toast visible until another toast replaces it or the user dismisses it.
+
+## Global Configuration
+
+Use `configureToast` once during app startup to customize the base style or built-in variant styles for every toast.
+
+```ts
+import { configureToast, resetToastConfig } from '@synonymdev/react-native-toast';
+
+configureToast({
+	options: {
+		haptics: true,
+		dismissible: true,
+		durationMs: 4000,
+	},
+	defaults: {
+		borderRadius: 16,
+		paddingHorizontal: 24,
+	},
+	variants: {
+		success: {
+			backgroundColor: '#047857',
+			borderColor: '#34D399',
+		},
+		error: {
+			backgroundColor: '#991B1B',
+			borderColor: '#FCA5A5',
+		},
+	},
+});
+
+resetToastConfig();
+```
+
+```ts
+type NativeToastVariantStyles = Partial<
+	Record<NativeToastVariant, NativeToastStyle>
+>;
+
+type NativeToastDefaultOptions = Pick<
+	ToastOptions,
+	'autoHide' | 'dismissible' | 'haptics' | 'durationMs'
+>;
+
+type NativeToastConfig = {
+	defaults?: NativeToastStyle;
+	variants?: NativeToastVariantStyles;
+	options?: NativeToastDefaultOptions;
+};
+```
+
+Configured behavior options are merged in this order:
+
+1. Configured `options`.
+2. Per-toast options.
+
+Per-toast options always win.
+
+Configured styles are merged in this order:
+
+1. Built-in default style.
+2. Configured `defaults`.
+3. Built-in variant style.
+4. Configured variant style.
+5. Per-toast `style`.
+
+## Styling
+
+Pass `style` to override the native toast appearance.
+
+```ts
+showToast({
+	type: 'info',
+	title: 'New message',
+	description: 'You have a new notification.',
+	style: {
+		backgroundColor: '#111111',
+		iosBlurEffect: 'systemThinMaterialDark',
+		iosBlurAmount: 20,
+		iosBlurTintOpacity: 0.72,
+		borderColor: '#333333',
+		borderRadius: 12,
+		borderWidth: 1,
+		paddingHorizontal: 20,
+		paddingVertical: 16,
+		width: 320,
+		maxWidth: 420,
+		titleColor: '#FFFFFF',
+		titleFontSize: 15,
+		descriptionColor: '#D4D4D4',
+		descriptionFontSize: 13,
+		shadowColor: '#000000',
+		shadowOpacity: 0.35,
+		shadowRadius: 16,
+		shadowOffsetY: 8,
+		shadowElevation: 8,
+		animation: 'slide-fade',
+		animationDurationMs: 200,
+	},
+});
+```
+
+## Style Options
+
+```ts
+type NativeToastBlurEffect =
+	| 'none'
+	| 'extraLight'
+	| 'light'
+	| 'dark'
+	| 'regular'
+	| 'prominent'
+	| 'systemUltraThinMaterial'
+	| 'systemThinMaterial'
+	| 'systemMaterial'
+	| 'systemThickMaterial'
+	| 'systemChromeMaterial'
+	| 'systemUltraThinMaterialLight'
+	| 'systemThinMaterialLight'
+	| 'systemMaterialLight'
+	| 'systemThickMaterialLight'
+	| 'systemChromeMaterialLight'
+	| 'systemUltraThinMaterialDark'
+	| 'systemThinMaterialDark'
+	| 'systemMaterialDark'
+	| 'systemThickMaterialDark'
+	| 'systemChromeMaterialDark';
+
+type NativeToastStyle = {
+	backgroundColor?: string;
+	iosBlurEffect?: NativeToastBlurEffect;
+	iosBlurAmount?: number;
+	iosBlurTintOpacity?: number;
+	borderRadius?: number;
+	borderColor?: string;
+	borderWidth?: number;
+	shadowColor?: string;
+	shadowOpacity?: number;
+	shadowRadius?: number;
+	shadowOffsetX?: number;
+	shadowOffsetY?: number;
+	shadowElevation?: number;
+	animation?: 'none' | 'fade' | 'slide' | 'slide-fade';
+	animationDurationMs?: number;
+	width?: number;
+	maxWidth?: number;
+	marginHorizontal?: number;
+	padding?: number;
+	paddingHorizontal?: number;
+	paddingVertical?: number;
+	paddingTop?: number;
+	paddingRight?: number;
+	paddingBottom?: number;
+	paddingLeft?: number;
+	titleColor?: string;
+	titleFontFamily?: string;
+	titleFontSize?: number;
+	titleFontWeight?: 'normal' | 'medium' | 'semibold' | 'bold';
+	descriptionColor?: string;
+	descriptionFontFamily?: string;
+	descriptionFontSize?: number;
+	descriptionFontWeight?: 'normal' | 'medium' | 'semibold' | 'bold';
+};
+```
+
+`iosBlurEffect` uses native `UIBlurEffect` on iOS and is ignored by Android. `iosBlurAmount` controls the custom blur radius and defaults to `20`. `iosBlurTintOpacity` controls the opacity of the `backgroundColor` tint layered over the blur and defaults to `0.72`.
+
+Supported animations are `none`, `fade`, `slide`, and `slide-fade`.

package/DEVELOPMENT.md

@@ -0,0 +1,35 @@
+# Development
+
+## Example App
+
+The `example` directory contains a small React Native app that links this package locally and demonstrates the main toast flows.
+
+```sh
+cd example
+yarn install
+yarn pods
+yarn start
+```
+
+Run it from another terminal:
+
+```sh
+yarn ios
+yarn android
+```
+
+## Package Commands
+
+Run tests:
+
+```sh
+yarn test
+```
+
+Build the package:
+
+```sh
+yarn build
+```
+
+The React Native entry points at `src/index.ts` for local app development. Published JavaScript and TypeScript declarations are emitted to `lib`.

package/README.md

@@ -0,0 +1,62 @@
+# @synonymdev/react-native-toast
+
+Native toast notifications for React Native.
+
+Renders toasts from native iOS and Android code so notifications can appear above native sheet presentation surfaces.
+
+Designed for use with native sheet implementations like React Navigation `formSheet`, [software-mansion-labs/react-native-bottom-sheet](https://github.com/software-mansion-labs/react-native-bottom-sheet) and [lodev09/react-native-true-sheet](https://github.com/lodev09/react-native-true-sheet).
+
+## Demo
+
+<video src="https://github.com/synonymdev/react-native-toast/raw/main/media/demo.mov" controls width="300">
+  <a href="./media/demo.mov">Watch the demo</a>
+</video>
+
+## Features
+
+- Native iOS and Android rendering.
+- Appears above native sheet presentation surfaces.
+- Simple `showToast(options)` JavaScript API.
+- Built-in `success`, `info`, `warning`, and `error` variants.
+- Typed options for behavior, haptics, blur, and styling.
+- Global configuration for default behavior and variant styling.
+
+## Why?
+
+React Native toast components usually render inside the JavaScript view hierarchy. That works for normal screens, but it can fall behind native sheet presentation layers.
+
+This package sends a fully resolved toast payload to a small native module, then renders the toast from native iOS and Android code. That makes it useful for app-level feedback that should remain visible across native sheet presentations.
+
+On Android, React Native `Modal` and modal-backed sheet libraries create their own native window. This toast currently renders in the Activity window, so those modal surfaces can appear above it.
+
+## Installation
+
+```sh
+yarn add @synonymdev/react-native-toast
+```
+
+## Usage
+
+```ts
+import { showToast } from '@synonymdev/react-native-toast';
+
+showToast({
+	type: 'success',
+	title: 'Saved',
+	description: 'Your changes are ready.',
+});
+```
+
+Configure shared defaults once during app startup:
+
+```ts
+import { configureToast } from '@synonymdev/react-native-toast';
+
+configureToast({
+	options: {
+		haptics: true,
+	},
+});
+```
+
+See [API.md](./API.md) for configuration, styling, and the full type reference. Local development and example app instructions live in [DEVELOPMENT.md](./DEVELOPMENT.md).

package/SynonymReactNativeToast.podspec

@@ -0,0 +1,17 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name         = 'SynonymReactNativeToast'
+  s.version      = package['version']
+  s.summary      = package['description']
+  s.license      = package['license']
+  s.authors      = { 'Synonym' => 'engineering@synonym.to' }
+  s.homepage     = 'https://github.com/synonymdev'
+  s.platforms    = { :ios => '13.0' }
+  s.source       = { :git => 'https://github.com/synonymdev/react-native-toast.git', :tag => s.version.to_s }
+  s.source_files = 'ios/**/*.{h,m,mm,swift}'
+
+  s.dependency 'React-Core'
+end

package/android/build.gradle

@@ -0,0 +1,24 @@
+buildscript {
+  ext.safeExtGet = { prop, fallback ->
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+  }
+}
+
+plugins {
+  id "com.android.library"
+  id "org.jetbrains.kotlin.android"
+}
+
+android {
+  namespace "com.synonymdev.reactnativetoast"
+  compileSdk safeExtGet("compileSdkVersion", 36)
+
+  defaultConfig {
+    minSdkVersion safeExtGet("minSdkVersion", 24)
+    targetSdkVersion safeExtGet("targetSdkVersion", 36)
+  }
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

package/android/src/main/java/com/synonymdev/reactnativetoast/NativeToastModule.kt

@@ -0,0 +1,332 @@
+package com.synonymdev.reactnativetoast
+
+import android.graphics.Color
+import android.graphics.Typeface
+import android.graphics.drawable.GradientDrawable
+import android.os.Build
+import android.util.TypedValue
+import android.view.Gravity
+import android.view.HapticFeedbackConstants
+import android.view.MotionEvent
+import android.view.View
+import android.view.ViewGroup
+import android.view.WindowManager
+import android.widget.FrameLayout
+import android.widget.LinearLayout
+import android.widget.TextView
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.bridge.ReadableMap
+import kotlin.math.roundToInt
+
+class NativeToastModule(private val reactContext: ReactApplicationContext) :
+    ReactContextBaseJavaModule(reactContext) {
+  override fun getName(): String = "NativeToast"
+
+  @ReactMethod
+  fun show(options: ReadableMap) {
+    val title = options.getString("title").orEmpty()
+    val description = options.getString("description").orEmpty()
+    val variant = options.getString("type") ?: "info"
+    val autoHide = if (options.hasKey("autoHide") && !options.isNull("autoHide")) options.getBoolean("autoHide") else true
+    val dismissible = if (options.hasKey("dismissible") && !options.isNull("dismissible")) options.getBoolean("dismissible") else true
+    val haptics = if (options.hasKey("haptics") && !options.isNull("haptics")) options.getBoolean("haptics") else false
+    val durationMs = if (options.hasKey("durationMs")) options.getDouble("durationMs") else 4000.0
+    val style = if (options.hasKey("style") && !options.isNull("style")) options.getMap("style") else null
+    val animation = string(style, "animation", "slide-fade")
+    val animationDurationMs = number(style, "animationDurationMs", 200.0).coerceAtLeast(0.0).toLong()
+
+    if (title.isBlank() && description.isBlank()) {
+      return
+    }
+
+    reactContext.runOnUiQueueThread {
+      val activity = reactContext.currentActivity ?: return@runOnUiQueueThread
+      val root = activity.window.decorView as? ViewGroup ?: return@runOnUiQueueThread
+
+      root.findViewWithTag<View>(TOAST_TAG)?.let {
+        it.animate().cancel()
+        root.removeView(it)
+      }
+      root.clipChildren = false
+      root.clipToPadding = false
+
+      val paddingTop = padding(style, "paddingTop", "paddingVertical", 12.0)
+      val paddingRight = padding(style, "paddingRight", "paddingHorizontal", 16.0)
+      val paddingBottom = padding(style, "paddingBottom", "paddingVertical", 12.0)
+      val paddingLeft = padding(style, "paddingLeft", "paddingHorizontal", 16.0)
+      val marginHorizontal = dp(number(style, "marginHorizontal", 16.0))
+      val availableWidth = (screenWidth() - (marginHorizontal * 2)).coerceAtLeast(0)
+      val toastWidth = toastWidth(style, availableWidth)
+
+      val toast = LinearLayout(activity).apply {
+        tag = TOAST_TAG
+        alpha = if (animationUsesFade(animation)) 0f else 1f
+        clipToOutline = true
+        gravity = Gravity.CENTER_VERTICAL
+        orientation = LinearLayout.VERTICAL
+        visibility = View.INVISIBLE
+        setPadding(dp(paddingLeft), dp(paddingTop), dp(paddingRight), dp(paddingBottom))
+        isClickable = dismissible
+        importantForAccessibility = View.IMPORTANT_FOR_ACCESSIBILITY_NO_HIDE_DESCENDANTS
+        background =
+            GradientDrawable().apply {
+              setColor(color(style, "backgroundColor", Color.rgb(51, 51, 51)))
+              cornerRadius = dp(number(style, "borderRadius", 12.0)).toFloat()
+              setStroke(dp(number(style, "borderWidth", 1.0)), color(style, "borderColor", Color.rgb(68, 68, 68)))
+            }
+        elevation = dp(number(style, "shadowElevation", 8.0)).toFloat()
+        translationZ = elevation
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+          val shadowColor = color(style, "shadowColor", Color.BLACK)
+          outlineAmbientShadowColor = shadowColor
+          outlineSpotShadowColor = shadowColor
+        }
+      }
+
+      if (title.isNotBlank()) {
+        toast.addView(
+            TextView(activity).apply {
+              text = title
+              maxLines = 2
+              setTextColor(color(style, "titleColor", Color.WHITE))
+              setTextSize(TypedValue.COMPLEX_UNIT_SP, number(style, "titleFontSize", 15.0).toFloat())
+              typeface = typeface(style, "titleFontFamily", "titleFontWeight", Typeface.BOLD)
+              includeFontPadding = false
+            },
+            LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT),
+        )
+      }
+
+      if (description.isNotBlank()) {
+        toast.addView(
+            TextView(activity).apply {
+              text = description
+              maxLines = 3
+              setTextColor(color(style, "descriptionColor", Color.rgb(204, 204, 204)))
+              setTextSize(TypedValue.COMPLEX_UNIT_SP, number(style, "descriptionFontSize", 13.0).toFloat())
+              typeface = typeface(style, "descriptionFontFamily", "descriptionFontWeight", Typeface.NORMAL)
+              includeFontPadding = false
+            },
+            LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT).apply {
+              topMargin = if (title.isNotBlank()) dp(2.0) else 0
+            },
+        )
+      }
+
+      val layoutParams =
+          FrameLayout.LayoutParams(toastWidth, ViewGroup.LayoutParams.WRAP_CONTENT, Gravity.TOP or Gravity.CENTER_HORIZONTAL)
+              .apply {
+                topMargin = statusBarHeight() + dp(12.0)
+              }
+
+      root.addView(toast, layoutParams)
+      if (haptics) {
+        triggerHaptic(toast, variant)
+      }
+
+      toast.post {
+        val dismissedTranslation = if (animationUsesSlide(animation)) -(toast.height + layoutParams.topMargin + dp(8.0)).toFloat() else 0f
+        toast.translationY = dismissedTranslation
+        toast.visibility = View.VISIBLE
+        if (dismissible) {
+          configureDragDismiss(toast, root, dismissedTranslation, animationDurationMs)
+        }
+
+        toast
+            .animate()
+            .alpha(1f)
+            .translationY(0f)
+            .setDuration(animationDurationMs)
+            .withEndAction {
+              if (autoHide) {
+                toast.postDelayed(
+                    {
+                      toast
+                          .animate()
+                          .alpha(if (animationUsesFade(animation)) 0f else 1f)
+                          .translationY(dismissedTranslation)
+                          .setDuration(animationDurationMs)
+                          .withEndAction {
+                            if (toast.parent === root) {
+                              root.removeView(toast)
+                            }
+                          }
+                          .start()
+                    },
+                    durationMs.coerceAtLeast(1500.0).toLong(),
+                )
+              }
+            }
+            .start()
+      }
+    }
+  }
+
+  private fun triggerHaptic(view: View, variant: String) {
+    val feedbackConstant =
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+          when (variant) {
+            "success" -> HapticFeedbackConstants.CONFIRM
+            "warning" -> HapticFeedbackConstants.LONG_PRESS
+            "error" -> HapticFeedbackConstants.REJECT
+            else -> HapticFeedbackConstants.CONTEXT_CLICK
+          }
+        } else {
+          when (variant) {
+            "warning", "error" -> HapticFeedbackConstants.LONG_PRESS
+            else -> HapticFeedbackConstants.KEYBOARD_TAP
+          }
+        }
+
+    view.isHapticFeedbackEnabled = true
+    view.performHapticFeedback(feedbackConstant)
+  }
+
+  private fun color(style: ReadableMap?, key: String, fallback: Int): Int {
+    val value = if (style?.hasKey(key) == true && !style.isNull(key)) style.getString(key) else null
+    return try {
+      if (value.isNullOrBlank()) fallback else Color.parseColor(value)
+    } catch (_: IllegalArgumentException) {
+      fallback
+    }
+  }
+
+  private fun number(style: ReadableMap?, key: String, fallback: Double): Double {
+    return if (style?.hasKey(key) == true && !style.isNull(key)) style.getDouble(key) else fallback
+  }
+
+  private fun string(style: ReadableMap?, key: String, fallback: String): String {
+    return if (style?.hasKey(key) == true && !style.isNull(key)) style.getString(key) ?: fallback else fallback
+  }
+
+  private fun animationUsesFade(animation: String): Boolean {
+    return animation != "none" && animation != "slide"
+  }
+
+  private fun animationUsesSlide(animation: String): Boolean {
+    return animation == "slide" || animation == "slide-fade"
+  }
+
+  private fun optionalNumber(style: ReadableMap?, key: String): Double? {
+    return if (style?.hasKey(key) == true && !style.isNull(key)) style.getDouble(key) else null
+  }
+
+  private fun toastWidth(style: ReadableMap?, availableWidth: Int): Int {
+    val width = optionalNumber(style, "width")?.let { dp(it).coerceIn(0, availableWidth) }
+    if (width != null) {
+      return width
+    }
+
+    val maxWidth = optionalNumber(style, "maxWidth")?.let { dp(it).coerceIn(0, availableWidth) }
+    return maxWidth ?: availableWidth
+  }
+
+  private fun padding(style: ReadableMap?, edgeKey: String, axisKey: String, fallback: Double): Double {
+    return when {
+      style?.hasKey(edgeKey) == true && !style.isNull(edgeKey) -> style.getDouble(edgeKey)
+      style?.hasKey(axisKey) == true && !style.isNull(axisKey) -> style.getDouble(axisKey)
+      style?.hasKey("padding") == true && !style.isNull("padding") -> style.getDouble("padding")
+      else -> fallback
+    }
+  }
+
+  private fun typeface(style: ReadableMap?, familyKey: String, weightKey: String, fallbackStyle: Int): Typeface {
+    val family = if (style?.hasKey(familyKey) == true && !style.isNull(familyKey)) style.getString(familyKey) else null
+    val fontStyle =
+        when (if (style?.hasKey(weightKey) == true && !style.isNull(weightKey)) style.getString(weightKey) else null) {
+          "bold", "semibold" -> Typeface.BOLD
+          "medium" -> Typeface.NORMAL
+          "normal" -> Typeface.NORMAL
+          else -> fallbackStyle
+        }
+
+    return if (family.isNullOrBlank()) {
+      Typeface.defaultFromStyle(fontStyle)
+    } else {
+      Typeface.create(family, fontStyle)
+    }
+  }
+
+  private fun configureDragDismiss(
+      toast: View,
+      root: ViewGroup,
+      dismissedTranslation: Float,
+      animationDurationMs: Long,
+  ) {
+    var downRawY = 0f
+
+    toast.setOnTouchListener { view, event ->
+      when (event.actionMasked) {
+        MotionEvent.ACTION_DOWN -> {
+          view.animate().cancel()
+          downRawY = event.rawY
+          view.parent?.requestDisallowInterceptTouchEvent(true)
+          true
+        }
+        MotionEvent.ACTION_MOVE -> {
+          val offsetY = (event.rawY - downRawY).coerceAtMost(0f)
+          view.translationY = offsetY
+          view.alpha = (1f + (offsetY / view.height.coerceAtLeast(1))).coerceAtLeast(0.35f)
+          true
+        }
+        MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
+          val offsetY = (event.rawY - downRawY).coerceAtMost(0f)
+          val shouldDismiss = offsetY < -dp(40.0)
+          view.parent?.requestDisallowInterceptTouchEvent(false)
+
+          if (shouldDismiss) {
+            view
+                .animate()
+                .alpha(0f)
+                .translationY(dismissedTranslation)
+                .setDuration(160L)
+                .withEndAction {
+                  if (view.parent === root) {
+                    root.removeView(view)
+                  }
+                }
+                .start()
+          } else {
+            view
+                .animate()
+                .alpha(1f)
+                .translationY(0f)
+                .setDuration(animationDurationMs.coerceAtMost(160L))
+                .start()
+          }
+          true
+        }
+        else -> false
+      }
+    }
+  }
+
+  private fun dp(value: Double): Int {
+    return TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, value.toFloat(), reactContext.resources.displayMetrics)
+        .roundToInt()
+  }
+
+  private fun statusBarHeight(): Int {
+    val resourceId = reactContext.resources.getIdentifier("status_bar_height", "dimen", "android")
+    return if (resourceId > 0) reactContext.resources.getDimensionPixelSize(resourceId) else 0
+  }
+
+  private fun screenWidth(): Int {
+    val activity = reactContext.currentActivity ?: return reactContext.resources.displayMetrics.widthPixels
+    return if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.R) {
+      activity.windowManager.currentWindowMetrics.bounds.width()
+    } else {
+      @Suppress("DEPRECATION")
+      val display = (activity.getSystemService(android.content.Context.WINDOW_SERVICE) as WindowManager).defaultDisplay
+      @Suppress("DEPRECATION")
+      val metrics = android.util.DisplayMetrics().also { display.getMetrics(it) }
+      metrics.widthPixels
+    }
+  }
+
+  private companion object {
+    const val TOAST_TAG = 900413
+  }
+}

package/android/src/main/java/com/synonymdev/reactnativetoast/NativeToastPackage.kt

@@ -0,0 +1,15 @@
+package com.synonymdev.reactnativetoast
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class NativeToastPackage : ReactPackage {
+  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
+      listOf(NativeToastModule(reactContext))
+
+  override fun createViewManagers(
+      reactContext: ReactApplicationContext
+  ): List<ViewManager<*, *>> = emptyList()
+}