@dashx/react-native 1.2.0 → 1.3.1

package/android/build/reports/tests/testDebugUnitTest/js/report.js

@@ -0,0 +1,218 @@
+(function (window, document) {
+    "use strict";
+
+    function changeElementClass(element, classValue) {
+        if (element.getAttribute("className")) {
+            element.setAttribute("className", classValue);
+        } else {
+            element.setAttribute("class", classValue);
+        }
+    }
+
+    function getClassAttribute(element) {
+        if (element.getAttribute("className")) {
+            return element.getAttribute("className");
+        } else {
+            return element.getAttribute("class");
+        }
+    }
+
+    function addClass(element, classValue) {
+        changeElementClass(element, getClassAttribute(element) + " " + classValue);
+    }
+
+    function removeClass(element, classValue) {
+        changeElementClass(element, getClassAttribute(element).replace(classValue, ""));
+    }
+
+    function getCheckBox() {
+        return document.getElementById("line-wrapping-toggle");
+    }
+
+    function getLabelForCheckBox() {
+        return document.getElementById("label-for-line-wrapping-toggle");
+    }
+
+    function findCodeBlocks() {
+        const codeBlocks = [];
+        const tabContainers = getTabContainers();
+        for (let i = 0; i < tabContainers.length; i++) {
+            const spans = tabContainers[i].getElementsByTagName("span");
+            for (let i = 0; i < spans.length; ++i) {
+                if (spans[i].className.indexOf("code") >= 0) {
+                    codeBlocks.push(spans[i]);
+                }
+            }
+        }
+        return codeBlocks;
+    }
+
+    function forAllCodeBlocks(operation) {
+        const codeBlocks = findCodeBlocks();
+
+        for (let i = 0; i < codeBlocks.length; ++i) {
+            operation(codeBlocks[i], "wrapped");
+        }
+    }
+
+    function toggleLineWrapping() {
+        const checkBox = getCheckBox();
+
+        if (checkBox.checked) {
+            forAllCodeBlocks(addClass);
+        } else {
+            forAllCodeBlocks(removeClass);
+        }
+    }
+
+    function initControls() {
+        if (findCodeBlocks().length > 0) {
+            const checkBox = getCheckBox();
+            const label = getLabelForCheckBox();
+
+            checkBox.onclick = toggleLineWrapping;
+            checkBox.checked = false;
+
+            removeClass(label, "hidden");
+         }
+    }
+
+    class TabManager {
+        baseId;
+        tabs;
+        titles;
+        headers;
+
+        constructor(baseId, tabs, titles, headers) {
+            this.baseId = baseId;
+            this.tabs = tabs;
+            this.titles = titles;
+            this.headers = headers;
+        }
+
+        select(i) {
+            this.deselectAll();
+
+            changeElementClass(this.tabs[i], "tab selected");
+            changeElementClass(this.headers[i], "selected");
+
+            while (this.headers[i].firstChild) {
+                this.headers[i].removeChild(this.headers[i].firstChild);
+            }
+
+            const a = document.createElement("a");
+
+            a.appendChild(document.createTextNode(this.titles[i]));
+            this.headers[i].appendChild(a);
+        }
+
+        deselectAll() {
+            for (let i = 0; i < this.tabs.length; i++) {
+                changeElementClass(this.tabs[i], "tab deselected");
+                changeElementClass(this.headers[i], "deselected");
+
+                while (this.headers[i].firstChild) {
+                    this.headers[i].removeChild(this.headers[i].firstChild);
+                }
+
+                const a = document.createElement("a");
+
+                const id = this.baseId + "-tab" + i;
+                a.setAttribute("id", id);
+                a.setAttribute("href", "#tab" + i);
+                a.onclick = () => {
+                    this.select(i);
+                    return false;
+                };
+                a.appendChild(document.createTextNode(this.titles[i]));
+
+                this.headers[i].appendChild(a);
+            }
+        }
+    }
+
+    function getTabContainers() {
+        const tabContainers = Array.from(document.getElementsByClassName("tab-container"));
+
+        // Used by existing TabbedPageRenderer users, which have not adjusted to use TabsRenderer yet.
+        const legacyContainer = document.getElementById("tabs");
+        if (legacyContainer) {
+            tabContainers.push(legacyContainer);
+        }
+
+        return tabContainers;
+    }
+
+    function initTabs() {
+        let tabGroups = 0;
+
+        function createTab(num, container) {
+            const tabElems = findTabs(container);
+            const tabManager = new TabManager("tabs" + num, tabElems, findTitles(tabElems), findHeaders(container));
+            tabManager.select(0);
+        }
+
+        const tabContainers = getTabContainers();
+
+        for (let i = 0; i < tabContainers.length; i++) {
+            createTab(tabGroups, tabContainers[i]);
+            tabGroups++;
+        }
+
+        return true;
+    }
+
+    function findTabs(container) {
+        return findChildElements(container, "DIV", "tab");
+    }
+
+    function findHeaders(container) {
+        const owner = findChildElements(container, "UL", "tabLinks");
+        return findChildElements(owner[0], "LI", null);
+    }
+
+    function findTitles(tabs) {
+        const titles = [];
+
+        for (let i = 0; i < tabs.length; i++) {
+            const tab = tabs[i];
+            const header = findChildElements(tab, "H2", null)[0];
+
+            header.parentNode.removeChild(header);
+
+            if (header.innerText) {
+                titles.push(header.innerText);
+            } else {
+                titles.push(header.textContent);
+            }
+        }
+
+        return titles;
+    }
+
+    function findChildElements(container, name, targetClass) {
+        const elements = [];
+        const children = container.childNodes;
+
+        for (let i = 0; i < children.length; i++) {
+            const child = children.item(i);
+
+            if (child.nodeType === 1 && child.nodeName === name) {
+                if (targetClass && child.className.indexOf(targetClass) < 0) {
+                    continue;
+                }
+
+                elements.push(child);
+            }
+        }
+
+        return elements;
+    }
+
+    // Entry point.
+
+    window.onload = function() {
+        initTabs();
+        initControls();
+    };
+} (window, window.document));

package/android/build/reports/tests/testDebugUnitTest/packages/com.dashx.rn.sdk.util.html

@@ -0,0 +1,103 @@
+<!DOCTYPE html>
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+<meta http-equiv="x-ua-compatible" content="IE=edge"/>
+<title>Test results - Package com.dashx.rn.sdk.util</title>
+<link href="../css/base-style.css" rel="stylesheet" type="text/css"/>
+<link href="../css/style.css" rel="stylesheet" type="text/css"/>
+<script src="../js/report.js" type="text/javascript"></script>
+</head>
+<body>
+<div id="content">
+<h1>Package com.dashx.rn.sdk.util</h1>
+<div class="breadcrumbs">
+<a href="../index.html">all</a> &gt; com.dashx.rn.sdk.util</div>
+<div id="summary">
+<table>
+<tr>
+<td>
+<div class="summaryGroup">
+<table>
+<tr>
+<td>
+<div class="infoBox" id="tests">
+<div class="counter">16</div>
+<p>tests</p>
+</div>
+</td>
+<td>
+<div class="infoBox" id="failures">
+<div class="counter">0</div>
+<p>failures</p>
+</div>
+</td>
+<td>
+<div class="infoBox" id="ignored">
+<div class="counter">0</div>
+<p>ignored</p>
+</div>
+</td>
+<td>
+<div class="infoBox" id="duration">
+<div class="counter">0.012s</div>
+<p>duration</p>
+</div>
+</td>
+</tr>
+</table>
+</div>
+</td>
+<td>
+<div class="infoBox success" id="successRate">
+<div class="percent">100%</div>
+<p>successful</p>
+</div>
+</td>
+</tr>
+</table>
+</div>
+<div class="tab-container">
+<ul class="tabLinks">
+<li>
+<a href="#">Classes</a>
+</li>
+</ul>
+<div class="tab">
+<h2>Classes</h2>
+<table>
+<thead>
+<tr>
+<th>Class</th>
+<th>Tests</th>
+<th>Failures</th>
+<th>Ignored</th>
+<th>Duration</th>
+<th>Success rate</th>
+</tr>
+</thead>
+<tr>
+<td class="success">
+<a href="../classes/com.dashx.rn.sdk.util.UtilsTest.html">UtilsTest</a>
+</td>
+<td>16</td>
+<td>0</td>
+<td>0</td>
+<td>0.012s</td>
+<td class="success">100%</td>
+</tr>
+</table>
+</div>
+</div>
+<div id="footer">
+<p>
+<div>
+<label class="hidden" id="label-for-line-wrapping-toggle" for="line-wrapping-toggle">Wrap lines
+<input id="line-wrapping-toggle" type="checkbox" autocomplete="off"/>
+</label>
+</div>Generated by 
+<a href="https://www.gradle.org">Gradle 8.14.3</a> at 21-Apr-2026, 12:26:12 pm</p>
+</div>
+</div>
+</body>
+</html>

package/android/build/test-results/testDebugUnitTest/TEST-com.dashx.rn.sdk.util.UtilsTest.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<testsuite name="com.dashx.rn.sdk.util.UtilsTest" tests="16" skipped="0" failures="0" errors="0" timestamp="2026-04-21T06:56:12.862Z" hostname="Gulshans-MacBook-Pro.local" time="0.013">
+  <properties/>
+  <testcase name="convertMapToJson_nestedArray" classname="com.dashx.rn.sdk.util.UtilsTest" time="0.007"/>
+  <testcase name="convertJsonToMap_doesNotCrashOnNestedJsonNull" classname="com.dashx.rn.sdk.util.UtilsTest" time="0.0"/>
+  <testcase name="convertArrayToJson_mixedPrimitives" classname="com.dashx.rn.sdk.util.UtilsTest" time="0.002"/>
+  <testcase name="convertMapToJson_nullInputIsSafe" classname="com.dashx.rn.sdk.util.UtilsTest" time="0.0"/>
+  <testcase name="convertJsonToMap_primitives" classname="com.dashx.rn.sdk.util.UtilsTest" time="0.0"/>
+  <testcase name="convertMapToJson_primitives" classname="com.dashx.rn.sdk.util.UtilsTest" time="0.0"/>
+  <testcase name="roundTrip_preservesEverything" classname="com.dashx.rn.sdk.util.UtilsTest" time="0.001"/>
+  <testcase name="convertReadableArrayToKJsonList_returnsNullForEmpty" classname="com.dashx.rn.sdk.util.UtilsTest" time="0.0"/>
+  <testcase name="convertReadableArrayToKJsonList_filtersNonMapEntries" classname="com.dashx.rn.sdk.util.UtilsTest" time="0.001"/>
+  <testcase name="convertArrayToJson_returnsNullForNullInput" classname="com.dashx.rn.sdk.util.UtilsTest" time="0.0"/>
+  <testcase name="convertJsonToMap_nestedObject" classname="com.dashx.rn.sdk.util.UtilsTest" time="0.0"/>
+  <testcase name="convertJsonToMap_returnsNullForNullInput" classname="com.dashx.rn.sdk.util.UtilsTest" time="0.0"/>
+  <testcase name="convertMapToJson_returnsNullForNullInput" classname="com.dashx.rn.sdk.util.UtilsTest" time="0.0"/>
+  <testcase name="convertJsonToMap_nestedArray" classname="com.dashx.rn.sdk.util.UtilsTest" time="0.0"/>
+  <testcase name="convertMapToJson_emptyMapProducesEmptyJsonObject" classname="com.dashx.rn.sdk.util.UtilsTest" time="0.0"/>
+  <testcase name="convertMapToJson_nestedMap" classname="com.dashx.rn.sdk.util.UtilsTest" time="0.001"/>
+  <system-out><![CDATA[]]></system-out>
+  <system-err><![CDATA[]]></system-err>
+</testsuite>

package/android/build.gradle

@@ -1,5 +1,22 @@
 import groovy.json.JsonSlurper
 
+// Standalone build path (used by CI via `./gradlew :testDebugUnitTest` from
+// this `android/` directory). When consumer apps autolink the bridge, this
+// buildscript block is evaluated as a subproject too but is a no-op since
+// the consumer's root already provides identical or newer classpath
+// entries — AGP/Kotlin plugin classes are loaded once and shared.
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+    gradlePluginPortal()
+  }
+  dependencies {
+    classpath 'com.android.tools.build:gradle:8.7.2'
+    classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin:2.2.0'
+  }
+}
+
 apply plugin: 'com.android.library'
 apply plugin: 'kotlin-android'
 
@@ -34,6 +51,17 @@ android {
 
         buildConfigField 'String', 'VERSION_NAME', "\"$versionName\""
     }
+    // Align Java + Kotlin target so the standalone CI build (which doesn't
+    // inherit RN's defaults) doesn't trip "Inconsistent JVM-target
+    // compatibility". Consumers autolinking the bridge already set these
+    // at root scope; redeclaring here is a no-op when versions match.
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+    kotlinOptions {
+        jvmTarget = '17'
+    }
     lint {
         abortOnError false
     }
@@ -75,11 +103,19 @@ repositories {
 
 dependencies {
     compileOnly 'com.facebook.react:react-android:+'
-    implementation 'com.google.code.gson:gson:2.9.0'
+
     implementation 'org.jetbrains.kotlinx:kotlinx-serialization-json:1.9.0'
 
     // Ensure Firebase Messaging types are available for FCM service subclass
     implementation 'com.google.firebase:firebase-messaging-ktx:23.1.2'
 
-    implementation "com.dashx:dashx-android:1.2.5"
+    implementation "com.dashx:dashx-android:1.2.7"
+
+    // Unit tests for `util/Utils.kt` — JVM-only, no Robolectric. The RN
+    // `react-android` artifact is pulled in at test runtime (not as a
+    // runtime dep) so tests can reach `JavaOnlyMap` / `JavaOnlyArray` —
+    // pure-Java `ReadableMap` / `WritableMap` impls that stand in for the
+    // JNI-backed `WritableNativeMap` / `WritableNativeArray` in JVM tests.
+    testImplementation 'junit:junit:4.13.2'
+    testImplementation 'com.facebook.react:react-android:+'
 }

package/android/settings.gradle

@@ -0,0 +1,27 @@
+// Minimal standalone Gradle config so CI can run the bridge's unit tests
+// (`./gradlew :testDebugUnitTest`) without checking out a consumer app.
+//
+// Consumer apps don't read this file — when the bridge is autolinked by a
+// React Native app, the consumer's own `settings.gradle` drives the build
+// and this one is ignored. Both paths coexist.
+
+pluginManagement {
+  repositories {
+    gradlePluginPortal()
+    google()
+    mavenCentral()
+  }
+}
+
+dependencyResolutionManagement {
+  // CI may run without autolinking providing repositories — declare them
+  // here so `testImplementation 'com.facebook.react:react-android:+'` and
+  // the `com.dashx:dashx-android:x.y.z` runtime dep resolve.
+  repositoriesMode.set(RepositoriesMode.PREFER_SETTINGS)
+  repositories {
+    google()
+    mavenCentral()
+  }
+}
+
+rootProject.name = 'dashx-react-native'

package/android/src/main/java/com/dashx/rn/sdk/DashXNotificationClickedListener.kt

@@ -0,0 +1,113 @@
+package com.dashx.rn.sdk
+
+import com.dashx.android.DashXNotificationListener
+import com.dashx.android.DashXPayload
+import com.dashx.android.NavigationAction
+import com.dashx.rn.sdk.util.convertJsonToMap
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.encodeToJsonElement
+import kotlinx.serialization.json.jsonObject
+
+/**
+ * Bridges the dashx-android SDK's [DashXNotificationListener.onNotificationClicked]
+ * hook to the JS-side `DashX.onNotificationClicked(...)` listener registered via
+ * `NativeEventEmitter`. Mirrors the iOS emit shape from
+ * `ios/DashXNotificationHandler.swift` → `handleNotificationResponse`:
+ *
+ * ```json
+ * {
+ *   "notification":      { ...DashX payload keys... },
+ *   "action":            { "type": "deepLink" | "screen" | ..., ... } | null,
+ *   "actionIdentifier":  "<string, or empty>"
+ * }
+ * ```
+ *
+ * Registered from [DashXReactNativeModuleImpl.initialize] via
+ * [DashX.registerNotificationListener], and unregistered in [invalidate].
+ *
+ * Returns `false` from [onNotificationClicked] so the SDK proceeds with its
+ * default navigation (deep-link intent, rich-landing browser, click-action
+ * intent). Consumers who want to override need to do so in JS — the
+ * JS-side listener has no way to suppress the native default via a return
+ * value, which matches iOS behavior.
+ *
+ * `actionIdentifier` is `null` when the notification body was tapped, or the
+ * tapped action button's identifier (matches `ActionButton.identifier`) for
+ * button taps. We emit an empty string in the body-tap case so the JS event
+ * always carries a String — matches the iOS event shape, where the field is
+ * always present.
+ */
+class DashXNotificationClickedListener(
+    private val reactContext: ReactApplicationContext
+) : DashXNotificationListener {
+
+    override fun onNotificationClicked(
+        payload: DashXPayload,
+        action: NavigationAction?,
+        actionIdentifier: String?
+    ): Boolean {
+        if (!reactContext.hasActiveReactInstance()) {
+            // RN is still booting (common on cold-start from a killed-app
+            // notification tap). The JS emit would be dropped anyway; skip.
+            return false
+        }
+
+        val body: WritableMap = Arguments.createMap().apply {
+            putMap("notification", payloadToMap(payload))
+            if (action != null) {
+                putMap("action", actionToMap(action))
+            } else {
+                putNull("action")
+            }
+            putString("actionIdentifier", actionIdentifier ?: "")
+        }
+
+        reactContext
+            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+            .emit("notificationClicked", body)
+
+        return false
+    }
+
+    private fun payloadToMap(payload: DashXPayload): WritableMap {
+        // DashXPayload is `@Serializable` — go straight to a JsonObject tree
+        // and hand it to the shared `convertJsonToMap` helper for a
+        // RN-bridge-safe `WritableMap`. No Gson / no string round-trip.
+        val jsonObject = Json.encodeToJsonElement(DashXPayload.serializer(), payload).jsonObject
+        return convertJsonToMap(jsonObject) ?: Arguments.createMap()
+    }
+
+    private fun actionToMap(action: NavigationAction): WritableMap {
+        val map = Arguments.createMap()
+        when (action) {
+            is NavigationAction.DeepLink -> {
+                map.putString("type", "deepLink")
+                map.putString("url", action.url)
+            }
+            is NavigationAction.Screen -> {
+                map.putString("type", "screen")
+                map.putString("name", action.name)
+                action.data?.let { data ->
+                    val dataMap = Arguments.createMap()
+                    for ((key, value) in data) {
+                        dataMap.putString(key, value)
+                    }
+                    map.putMap("data", dataMap)
+                }
+            }
+            is NavigationAction.RichLanding -> {
+                map.putString("type", "richLanding")
+                map.putString("url", action.url)
+            }
+            is NavigationAction.ClickAction -> {
+                map.putString("type", "clickAction")
+                map.putString("action", action.action)
+            }
+        }
+        return map
+    }
+}