yaver-feedback-react-native 0.8.13 → 0.9.2

package/app.plugin.js

@@ -387,14 +387,135 @@ function withYaverAndroidHotReload(config) {
     },
   ]);
 
-  // Patch MainApplication to register the package and use hot bundle
+  // Patch MainApplication to register the package and use hot bundle.
+  //
+  // MainApplication is Kotlin on React Native 0.73+ (every current Expo
+  // template) and Java before that. The two need genuinely different code —
+  // `new Foo()`, `final`, and `@Override` are all syntax errors in Kotlin —
+  // so branch on the language Expo reports rather than assuming.
   config = withMainApplication(config, (config) => {
-    let contents = config.modResults.contents;
-
-    if (contents.includes("YaverHotReload")) {
+    if (config.modResults.contents.includes("YaverHotReload")) {
       return config;
     }
+    config.modResults.contents =
+      config.modResults.language === "kt"
+        ? patchMainApplicationKotlin(config.modResults.contents)
+        : patchMainApplicationJava(config.modResults.contents);
+    return config;
+  });
+
+  return config;
+}
+
+/**
+ * Insert `snippet` immediately before the closing brace of the method whose
+ * signature contains `anchor`, by matching braces from the method's opening
+ * one.
+ *
+ * The boot guard has to run at the END of onCreate: it touches
+ * reactNativeHost, and reaching that before super.onCreate() and
+ * SoLoader.init() would initialise React before its native libraries are
+ * loaded. Returns the contents unchanged if the anchor isn't found — a
+ * missing safety net is survivable, a corrupted MainApplication is not.
+ */
+function insertAtEndOfMethod(contents, anchor, snippet) {
+  const anchorIdx = contents.indexOf(anchor);
+  if (anchorIdx === -1) return contents;
+  const open = contents.indexOf("{", anchorIdx);
+  if (open === -1) return contents;
+
+  let depth = 0;
+  for (let i = open; i < contents.length; i++) {
+    const ch = contents[i];
+    if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        return contents.slice(0, i) + snippet + contents.slice(i);
+      }
+    }
+  }
+  return contents;
+}
 
+/** Kotlin MainApplication (React Native 0.73+). */
+function patchMainApplicationKotlin(contents) {
+  // Imports. Kotlin takes no semicolons.
+  contents = contents.replace(
+    "import com.facebook.react.ReactApplication",
+    "import com.facebook.react.ReactApplication\nimport io.yaver.feedback.YaverHotReloadModule\nimport io.yaver.feedback.YaverHotReloadPackage"
+  );
+
+  // Register the package. Anchor on `return packages` rather than on
+  // `packages.add(` — the template's only occurrence of that is inside a
+  // commented-out example line.
+  contents = contents.replace(
+    /(\n([ \t]*)return packages\n)/,
+    "\n$2packages.add(YaverHotReloadPackage())\n$1"
+  );
+
+  // Load a hot-pushed bundle when one is present. Inserted before
+  // getJSMainModuleName, which every Expo template defines.
+  if (!contents.includes("getJSBundleFile")) {
+    contents = contents.replace(
+      /(\n([ \t]*)override fun getJSMainModuleName\(\))/,
+      `
+$2override fun getJSBundleFile(): String? {
+$2  // Yaver Feedback SDK: load hot-reloaded bundle if available
+$2  val hotBundle = YaverHotReloadModule.getSavedBundleFile(application.applicationContext)
+$2  return hotBundle?.absolutePath ?: super.getJSBundleFile()
+$2}
+$1`
+    );
+  }
+
+  // Crash-revert safety net: clear the boot-attempt counter once the React
+  // context initialises (bundle loaded successfully), AND via a 10-s fallback
+  // in case that listener never fires (e.g. an infinite loop in the root
+  // component). If neither fires, YaverHotReloadModule.getSavedBundleFile()
+  // reverts to the APK-bundled bundle after 3 failed cold starts. Parity with
+  // YaverHotReload.swift on iOS.
+  if (!contents.includes("yaverHotReloadBootListener")) {
+    contents = insertAtEndOfMethod(
+      contents,
+      "override fun onCreate()",
+      `
+    // Yaver Feedback SDK hot-reload crash-revert safety net
+    val yaverHotReloadCtx: android.content.Context = applicationContext
+    android.os.Handler(android.os.Looper.getMainLooper()).postDelayed(
+      { YaverHotReloadModule.markBootSuccessful(yaverHotReloadCtx) },
+      10000
+    )
+    try {
+      // Anonymous object, not a lambda: SAM conversion needs a Java interface
+      // or a Kotlin \`fun interface\`, and as of RN 0.81
+      // com.facebook.react.ReactInstanceEventListener is a plain Kotlin
+      // interface (ReactInstanceEventListener.kt). A lambda there fails
+      // :app:compileReleaseKotlin with "Argument type mismatch: actual type is
+      // 'Function0<Unit>'" — i.e. the host app cannot build a release AAB at
+      // all. The Java path below already did this correctly.
+      reactNativeHost.reactInstanceManager.addReactInstanceEventListener(
+        object : com.facebook.react.ReactInstanceEventListener {
+          override fun onReactContextInitialized(
+            context: com.facebook.react.bridge.ReactContext
+          ) {
+            YaverHotReloadModule.markBootSuccessful(yaverHotReloadCtx)
+          }
+        }
+      )
+    } catch (yaverHotReloadBootListener: Throwable) {
+      // Bridgeless / New Architecture does not expose reactInstanceManager;
+      // the 10-s fallback above still covers us.
+    }
+`
+    );
+  }
+
+  return contents;
+}
+
+/** Java MainApplication (React Native < 0.73). */
+function patchMainApplicationJava(contents) {
     // Add import
     contents = contents.replace(
       "import com.facebook.react.ReactApplication",
@@ -468,11 +589,7 @@ function withYaverAndroidHotReload(config) {
         contents.slice(0, insertionPoint) + bootGuard + contents.slice(insertionPoint);
     }
 
-    config.modResults.contents = contents;
-    return config;
-  });
-
-  return config;
+  return contents;
 }
 
 function withYaverFeedback(config, props) {

package/dist/BlackBox.js

@@ -3,6 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlackBox = void 0;
 const react_native_1 = require("react-native");
 const YaverFeedback_1 = require("./YaverFeedback");
+function unrefTimer(timer) {
+    const maybeNodeTimer = timer;
+    if (typeof maybeNodeTimer.unref === 'function') {
+        maybeNodeTimer.unref();
+    }
+}
 class BlackBox {
     /**
      * Start the black box stream. Call after `YaverFeedback.init()`.
@@ -18,7 +24,7 @@ class BlackBox {
         }
         BlackBox.baseUrl = feedbackConfig.agentUrl.replace(/\/$/, '');
         BlackBox.authToken = feedbackConfig.authToken ?? null;
-        BlackBox.relayPassword = feedbackConfig.relayPassword ?? '';
+        BlackBox.relayPassword = YaverFeedback_1.YaverFeedback.getRelayPassword();
         BlackBox.deviceId = config?.deviceId ?? BlackBox.generateDeviceId();
         BlackBox.appName = config?.appName ?? '';
         BlackBox.flushInterval = config?.flushInterval ?? 2000;
@@ -29,6 +35,7 @@ class BlackBox {
         if (BlackBox.flushTimer)
             clearInterval(BlackBox.flushTimer);
         BlackBox.flushTimer = setInterval(() => BlackBox.flush(), BlackBox.flushInterval);
+        unrefTimer(BlackBox.flushTimer);
         // Log the session start
         BlackBox.push({
             type: 'lifecycle',
@@ -343,6 +350,7 @@ class BlackBox {
             if (BlackBox.started)
                 BlackBox.connectSSE();
         }, 5000);
+        unrefTimer(BlackBox.sseReconnectTimer);
     }
     // ─── Internal ────────────────────────────────────────────────────
     static push(event) {

package/dist/DeployPanel.js

@@ -151,6 +151,45 @@ const DeployPanel = ({ onClose }) => {
         </react_native_1.Text>
       </react_native_1.Pressable>);
     };
+    // First-class App Store screenshots: walk the app's routes on THIS
+    // device, screenshot each, upload to the agent (which runs the ASC
+    // backend). Closes the overlay first so the captures are clean (no
+    // modal in frame), then reports via an alert.
+    const runStoreShots = () => {
+        const cfg = YaverFeedback_1.YaverFeedback.getConfig();
+        const ss = cfg?.storeShots;
+        if (!ss?.routes?.length) {
+            setStatus('Set config.storeShots.routes (and a navigationRef) to enable.');
+            setStatusTone('error');
+            return;
+        }
+        const app = resolveAppSlug();
+        onClose();
+        // Defer so the overlay is fully dismissed before the first capture.
+        setTimeout(async () => {
+            try {
+                const res = await YaverFeedback_1.YaverFeedback.captureStoreScreenshots({
+                    app,
+                    routes: ss.routes,
+                    navigationRef: ss.navigationRef,
+                    screens: ss.screens,
+                    submit: ss.submit,
+                });
+                const msg = res.ok
+                    ? res.submitted
+                        ? 'Submitted for App Store review 🎉'
+                        : res.staged
+                            ? `Uploaded ${res.uploaded} screenshots — staged. One tap left in App Store Connect.`
+                            : `Uploaded ${res.uploaded} App Store screenshots.`
+                    : res.message || 'Capture failed.';
+                react_native_1.Alert.alert('App Store screenshots', msg);
+            }
+            catch (e) {
+                react_native_1.Alert.alert('App Store screenshots', e?.message ?? 'Capture failed.');
+            }
+        }, 500);
+    };
+    const storeShotsEnabled = (YaverFeedback_1.YaverFeedback.getConfig()?.storeShots?.routes?.length ?? 0) > 0;
     const triggerDeploy = async (machine) => {
         if (!options)
             return;
@@ -233,6 +272,13 @@ const DeployPanel = ({ onClose }) => {
           <react_native_1.ActivityIndicator color="rgba(255,255,255,0.6)"/>
         </react_native_1.View>) : error ? (<react_native_1.Text style={styles.error}>{error}</react_native_1.Text>) : options ? (<react_native_1.ScrollView style={styles.list}>{options.devices.map(machineRow)}</react_native_1.ScrollView>) : null}
 
+      {storeShotsEnabled && (<react_native_1.Pressable onPress={runStoreShots} disabled={shipping} style={({ pressed }) => [styles.shotsBtn, pressed && styles.rowPressed]}>
+          <react_native_1.Text style={styles.shotsBtnText}>📸 App Store screenshots</react_native_1.Text>
+          <react_native_1.Text style={styles.shotsBtnSub}>
+            capture this app on-device + upload to App Store Connect
+          </react_native_1.Text>
+        </react_native_1.Pressable>)}
+
       {status && (<react_native_1.Text style={[
                 styles.status,
                 statusTone === 'success' && styles.statusSuccess,
@@ -339,6 +385,25 @@ const styles = react_native_1.StyleSheet.create({
     rowMetaWarning: {
         color: 'rgb(255,178,115)',
     },
+    shotsBtn: {
+        marginTop: 12,
+        paddingVertical: 12,
+        paddingHorizontal: 14,
+        borderRadius: 10,
+        backgroundColor: 'rgba(124,109,255,0.16)',
+        borderWidth: 1,
+        borderColor: 'rgba(124,109,255,0.4)',
+    },
+    shotsBtnText: {
+        color: '#fff',
+        fontSize: 14,
+        fontWeight: '600',
+    },
+    shotsBtnSub: {
+        color: 'rgba(255,255,255,0.55)',
+        fontSize: 12,
+        marginTop: 2,
+    },
     status: {
         color: 'rgba(255,255,255,0.55)',
         fontSize: 12,

package/dist/Discovery.js

@@ -34,6 +34,12 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.YaverDiscovery = void 0;
+function unrefTimer(timer) {
+    const maybeNodeTimer = timer;
+    if (typeof maybeNodeTimer.unref === 'function') {
+        maybeNodeTimer.unref();
+    }
+}
 function getAsyncStorage() {
     try {
         const mod = require('@react-native-async-storage/async-storage');
@@ -333,14 +339,15 @@ class YaverDiscovery {
     static async probe(url) {
         const base = url.replace(/\/$/, '');
         const start = Date.now();
+        let timeoutId = null;
         try {
             const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+            timeoutId = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+            unrefTimer(timeoutId);
             const response = await fetch(`${base}/health`, {
                 method: 'GET',
                 signal: controller.signal,
             });
-            clearTimeout(timeoutId);
             if (!response.ok)
                 return null;
             const latency = Date.now() - start;
@@ -359,6 +366,10 @@ class YaverDiscovery {
         catch {
             return null;
         }
+        finally {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+        }
     }
     static async connect(url) {
         const result = await YaverDiscovery.probe(url);