@crumbsdk/react-native 0.0.1-rc.3 → 0.0.1-rc.4

package/nitrogen/generated/ios/CrumbReactNative-Swift-Cxx-Bridge.hpp

@@ -107,6 +107,15 @@ namespace margelo::nitro::crumbsdk_reactnative::bridge::swift {
     return Result<void>::withError(error);
   }
   
+  // pragma MARK: Result<bool>
+  using Result_bool_ = Result<bool>;
+  inline Result_bool_ create_Result_bool_(bool value) noexcept {
+    return Result<bool>::withValue(std::move(value));
+  }
+  inline Result_bool_ create_Result_bool_(const std::exception_ptr& error) noexcept {
+    return Result<bool>::withError(error);
+  }
+  
   // pragma MARK: Result<std::shared_ptr<Promise<bool>>>
   using Result_std__shared_ptr_Promise_bool___ = Result<std::shared_ptr<Promise<bool>>>;
   inline Result_std__shared_ptr_Promise_bool___ create_Result_std__shared_ptr_Promise_bool___(const std::shared_ptr<Promise<bool>>& value) noexcept {

package/nitrogen/generated/ios/c++/HybridCrumbReactNativeSpecSwift.hpp

@@ -73,6 +73,20 @@ namespace margelo::nitro::crumbsdk_reactnative {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void setScreenContext(const std::string& screenJson) override {
+      auto __result = _swiftPart.setScreenContext(screenJson);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline bool canCollectLogs() override {
+      auto __result = _swiftPart.canCollectLogs();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
     inline std::shared_ptr<Promise<bool>> installReporter() override {
       auto __result = _swiftPart.installReporter();
       if (__result.hasError()) [[unlikely]] {
@@ -81,8 +95,8 @@ namespace margelo::nitro::crumbsdk_reactnative {
       auto __value = std::move(__result.value());
       return __value;
     }
-    inline std::shared_ptr<Promise<bool>> show() override {
-      auto __result = _swiftPart.show();
+    inline std::shared_ptr<Promise<bool>> show(const std::string& screenJson) override {
+      auto __result = _swiftPart.show(screenJson);
       if (__result.hasError()) [[unlikely]] {
         std::rethrow_exception(__result.error());
       }
@@ -101,6 +115,20 @@ namespace margelo::nitro::crumbsdk_reactnative {
         std::rethrow_exception(__result.error());
       }
     }
+    inline void recordJavaScriptCrash(const std::string& recordJson) override {
+      auto __result = _swiftPart.recordJavaScriptCrash(recordJson);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+    }
+    inline std::shared_ptr<Promise<bool>> recoverJavaScriptCrashes() override {
+      auto __result = _swiftPart.recoverJavaScriptCrashes();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
 
   private:
     CrumbReactNative::HybridCrumbReactNativeSpec_cxx _swiftPart;

package/nitrogen/generated/ios/swift/HybridCrumbReactNativeSpec.swift

@@ -14,10 +14,14 @@ public protocol HybridCrumbReactNativeSpec_protocol: HybridObject {
 
   // Methods
   func start(configurationJson: String) throws -> Void
+  func setScreenContext(screenJson: String) throws -> Void
+  func canCollectLogs() throws -> Bool
   func installReporter() throws -> Promise<Bool>
-  func show() throws -> Promise<Bool>
+  func show(screenJson: String) throws -> Promise<Bool>
   func addLog(entryJson: String) throws -> Void
   func clearLogs() throws -> Void
+  func recordJavaScriptCrash(recordJson: String) throws -> Void
+  func recoverJavaScriptCrashes() throws -> Promise<Bool>
 }
 
 public extension HybridCrumbReactNativeSpec_protocol {

package/nitrogen/generated/ios/swift/HybridCrumbReactNativeSpec_cxx.swift

@@ -135,6 +135,29 @@ open class HybridCrumbReactNativeSpec_cxx {
     }
   }
   
+  @inline(__always)
+  public final func setScreenContext(screenJson: std.string) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.setScreenContext(screenJson: String(screenJson))
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func canCollectLogs() -> bridge.Result_bool_ {
+    do {
+      let __result = try self.__implementation.canCollectLogs()
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_bool_(__exceptionPtr)
+    }
+  }
+  
   @inline(__always)
   public final func installReporter() -> bridge.Result_std__shared_ptr_Promise_bool___ {
     do {
@@ -155,9 +178,9 @@ open class HybridCrumbReactNativeSpec_cxx {
   }
   
   @inline(__always)
-  public final func show() -> bridge.Result_std__shared_ptr_Promise_bool___ {
+  public final func show(screenJson: std.string) -> bridge.Result_std__shared_ptr_Promise_bool___ {
     do {
-      let __result = try self.__implementation.show()
+      let __result = try self.__implementation.show(screenJson: String(screenJson))
       let __resultCpp = { () -> bridge.std__shared_ptr_Promise_bool__ in
         let __promise = bridge.create_std__shared_ptr_Promise_bool__()
         let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_bool__(__promise)
@@ -194,4 +217,34 @@ open class HybridCrumbReactNativeSpec_cxx {
       return bridge.create_Result_void_(__exceptionPtr)
     }
   }
+  
+  @inline(__always)
+  public final func recordJavaScriptCrash(recordJson: std.string) -> bridge.Result_void_ {
+    do {
+      try self.__implementation.recordJavaScriptCrash(recordJson: String(recordJson))
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public final func recoverJavaScriptCrashes() -> bridge.Result_std__shared_ptr_Promise_bool___ {
+    do {
+      let __result = try self.__implementation.recoverJavaScriptCrashes()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_bool__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_bool__()
+        let __promiseHolder = bridge.wrap_std__shared_ptr_Promise_bool__(__promise)
+        __result
+          .then({ __result in __promiseHolder.resolve(__result) })
+          .catch({ __error in __promiseHolder.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_bool___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_bool___(__exceptionPtr)
+    }
+  }
 }

package/nitrogen/generated/shared/c++/HybridCrumbReactNativeSpec.cpp

@@ -15,10 +15,14 @@ namespace margelo::nitro::crumbsdk_reactnative {
     // load custom methods/properties
     registerHybrids(this, [](Prototype& prototype) {
       prototype.registerHybridMethod("start", &HybridCrumbReactNativeSpec::start);
+      prototype.registerHybridMethod("setScreenContext", &HybridCrumbReactNativeSpec::setScreenContext);
+      prototype.registerHybridMethod("canCollectLogs", &HybridCrumbReactNativeSpec::canCollectLogs);
       prototype.registerHybridMethod("installReporter", &HybridCrumbReactNativeSpec::installReporter);
       prototype.registerHybridMethod("show", &HybridCrumbReactNativeSpec::show);
       prototype.registerHybridMethod("addLog", &HybridCrumbReactNativeSpec::addLog);
       prototype.registerHybridMethod("clearLogs", &HybridCrumbReactNativeSpec::clearLogs);
+      prototype.registerHybridMethod("recordJavaScriptCrash", &HybridCrumbReactNativeSpec::recordJavaScriptCrash);
+      prototype.registerHybridMethod("recoverJavaScriptCrashes", &HybridCrumbReactNativeSpec::recoverJavaScriptCrashes);
     });
   }
 

package/nitrogen/generated/shared/c++/HybridCrumbReactNativeSpec.hpp

@@ -50,10 +50,14 @@ namespace margelo::nitro::crumbsdk_reactnative {
     public:
       // Methods
       virtual void start(const std::string& configurationJson) = 0;
+      virtual void setScreenContext(const std::string& screenJson) = 0;
+      virtual bool canCollectLogs() = 0;
       virtual std::shared_ptr<Promise<bool>> installReporter() = 0;
-      virtual std::shared_ptr<Promise<bool>> show() = 0;
+      virtual std::shared_ptr<Promise<bool>> show(const std::string& screenJson) = 0;
       virtual void addLog(const std::string& entryJson) = 0;
       virtual void clearLogs() = 0;
+      virtual void recordJavaScriptCrash(const std::string& recordJson) = 0;
+      virtual std::shared_ptr<Promise<bool>> recoverJavaScriptCrashes() = 0;
 
     protected:
       // Hybrid Setup

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crumbsdk/react-native",
-  "version": "0.0.1-rc.3",
+  "version": "0.0.1-rc.4",
   "description": "React Native adapter for the native Crumb issue-reporting SDK",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -10,7 +10,8 @@
       "types": "./lib/typescript/src/index.d.ts",
       "default": "./lib/module/index.js"
     },
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./app.plugin.js": "./app.plugin.js"
   },
   "files": [
     "src",
@@ -26,7 +27,11 @@
     "!ios/build",
     "!android/build",
     "!android/.cxx",
-    "!**/__tests__"
+    "!**/__tests__",
+    "native",
+    "scripts/ios.rb",
+    "app.plugin.js",
+    "plugin"
   ],
   "scripts": {
     "example": "yarn workspace @crumbsdk/react-native-example",
@@ -37,7 +42,12 @@
     "lint": "eslint \"**/*.{js,ts,tsx}\"",
     "test": "jest --runInBand",
     "quality": "yarn lint && yarn typecheck && yarn test && yarn prepare",
-    "pack:check": "yarn pack --dry-run"
+    "pack:check": "node scripts/verify-pack.mjs",
+    "prepare:ios": "node scripts/prepare-ios.mjs",
+    "prepack": "yarn prepare:ios",
+    "test:packaging": "node --test test/packaging/*.test.cjs",
+    "pack:check:ios": "node scripts/verify-pack.mjs --ios",
+    "pack:check:expo": "node scripts/verify-expo-consumer.mjs"
   },
   "keywords": [
     "react-native",
@@ -62,7 +72,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "crumbNativeVersion": "0.0.1-rc.3",
+  "crumbNativeVersion": "0.0.1-rc.4",
   "devDependencies": {
     "@babel/core": "7.29.7",
     "@eslint/compat": "2.1.0",

package/plugin/podfile.cjs

@@ -0,0 +1,21 @@
+const marker = '# crumb-bundled-ios';
+const block = `${marker}
+  require File.join(File.dirname(\`node --print "require.resolve('@crumbsdk/react-native/package.json')"\`.strip), 'scripts', 'ios')
+  crumb_native_pods!`;
+
+function configurePodfile(contents) {
+  if (contents.includes(marker)) return contents;
+  if (/pod\s+['"](?:CrumbSDK(?:Core|UI)?|PLCrashReporter)['"]/.test(contents)) {
+    throw new Error(
+      'Remove manual Crumb/PLCrashReporter pod entries before enabling the Crumb Expo plugin. It registers the bundled dependencies.'
+    );
+  }
+  const target = /^(\s*)use_expo_modules!\s*$/m;
+  if (!target.test(contents)) {
+    throw new Error(
+      'Crumb could not find use_expo_modules! in the Expo Podfile. Add crumb_native_pods! inside the app target using the bare React Native setup guide.'
+    );
+  }
+  return contents.replace(target, (match) => `${match}\n  ${block}\n`);
+}
+module.exports = { configurePodfile };

package/scripts/ios.rb

@@ -0,0 +1,23 @@
+require 'json'
+
+# Call once inside each application target, before use_react_native!.
+def crumb_native_pods!
+  package_root = File.expand_path('..', __dir__)
+  native_root = File.join(package_root, 'native', 'ios')
+  package = JSON.parse(File.read(File.join(package_root, 'package.json')))
+  required = [
+    'VERSION', 'CrumbSDKCore.podspec', 'CrumbSDKUI.podspec',
+    'packages/ios/Sources/CrumbCore/CrumbConfiguration.swift',
+    'PLCrashReporter/PLCrashReporter.podspec',
+    'PLCrashReporter/CrashReporter.xcframework/Info.plist'
+  ]
+  unless required.all? { |file| File.file?(File.join(native_root, file)) }
+    raise 'Crumb bundled iOS files are missing. Reinstall @crumbsdk/react-native; SDK contributors must run yarn prepare:ios before building.'
+  end
+  unless File.read(File.join(native_root, 'VERSION')).strip == package.fetch('crumbNativeVersion')
+    raise 'Crumb bundled iOS version does not match this npm package. Reinstall @crumbsdk/react-native.'
+  end
+  pod 'CrumbSDKCore', :path => native_root
+  pod 'CrumbSDKUI', :path => native_root
+  pod 'PLCrashReporter', :path => File.join(native_root, 'PLCrashReporter')
+end

package/src/CrumbReactNative.nitro.ts

@@ -5,8 +5,12 @@ export interface CrumbReactNative extends HybridObject<{
   android: 'kotlin';
 }> {
   start(configurationJson: string): void;
+  setScreenContext(screenJson: string): void;
+  canCollectLogs(): boolean;
   installReporter(): Promise<boolean>;
-  show(): Promise<boolean>;
+  show(screenJson: string): Promise<boolean>;
   addLog(entryJson: string): void;
   clearLogs(): void;
+  recordJavaScriptCrash(recordJson: string): void;
+  recoverJavaScriptCrashes(): Promise<boolean>;
 }

package/src/NativeCrumbReactNative.web.ts

@@ -11,10 +11,14 @@ const unsupportedModule: CrumbReactNative = {
   start: () => {
     throw new Error(unsupportedMessage);
   },
+  setScreenContext: () => undefined,
+  canCollectLogs: () => false,
   installReporter: () => Promise.resolve(false),
   show: () => Promise.resolve(false),
   addLog: () => undefined,
   clearLogs: () => undefined,
+  recordJavaScriptCrash: () => undefined,
+  recoverJavaScriptCrashes: () => Promise.resolve(false),
 };
 
 export default unsupportedModule;

package/src/index.ts

@@ -1,4 +1,16 @@
 import NativeCrumbReactNative from './NativeCrumbReactNative';
+import {
+  currentScreenJson,
+  setScreen,
+  trackReactNavigation,
+  useExpoRouterScreen,
+} from './screen-context';
+export { setScreen, trackReactNavigation, useExpoRouterScreen };
+export type { CrumbScreenOptions, CrumbNavigationRef } from './screen-context';
+import {
+  configureJavaScriptCrashCapture,
+  recoverJavaScriptCrashes,
+} from './javascript-crash-capture';
 import {
   clearLogs,
   configureLogBuffer,
@@ -9,21 +21,30 @@ import {
 } from './log-buffer';
 import type {
   CrumbConfiguration,
+  CrumbJavaScriptCrashCaptureOptions,
   CrumbLogLevel,
   CrumbLogMetadata,
 } from './types';
 
 export type {
+  CrumbApplicationMetadata,
   CrumbCaptureOptions,
   CrumbConfiguration,
+  CrumbCustomContextOptions,
   CrumbDiagnosticsOptions,
+  CrumbJavaScriptCrashCaptureOptions,
+  CrumbEvidenceCategory,
   CrumbInvocation,
   CrumbLogLevel,
   CrumbLogMetadata,
   CrumbLogOptions,
   CrumbPrivacyOptions,
+  CrumbReporterField,
+  CrumbReporterOptions,
   CrumbRelease,
+  CrumbTheme,
   CrumbUploadOptions,
+  CrumbWorkspacePolicyOptions,
 } from './types';
 
 export async function start(configuration: CrumbConfiguration): Promise<void> {
@@ -38,6 +59,14 @@ export async function start(configuration: CrumbConfiguration): Promise<void> {
   } else {
     disableConsoleCapture();
   }
+
+  configureJavaScriptCrashCapture(
+    configuration.diagnostics?.javascriptCrashCapture,
+    configuration
+  );
+  if (configuration.diagnostics?.javascriptCrashCapture?.enabled) {
+    await recoverJavaScriptCrashes();
+  }
 }
 
 export function installReporter(): Promise<boolean> {
@@ -45,7 +74,7 @@ export function installReporter(): Promise<boolean> {
 }
 
 export function show(): Promise<boolean> {
-  return NativeCrumbReactNative.show();
+  return NativeCrumbReactNative.show(currentScreenJson());
 }
 
 export function log(
@@ -93,6 +122,191 @@ function validateConfiguration(configuration: CrumbConfiguration): void {
     configuration.diagnostics?.logs?.maximumBytes,
     'diagnostics.logs.maximumBytes'
   );
+  if (
+    configuration.diagnostics?.renderingEnabled !== undefined &&
+    typeof configuration.diagnostics.renderingEnabled !== 'boolean'
+  ) {
+    throw new TypeError(
+      'Crumb diagnostics.renderingEnabled must be a boolean.'
+    );
+  }
+  assertJavaScriptCrashCapture(
+    configuration.diagnostics?.javascriptCrashCapture
+  );
+
+  if (
+    configuration.reporter?.theme !== undefined &&
+    !['system', 'light', 'dark'].includes(configuration.reporter.theme)
+  ) {
+    throw new TypeError('Crumb reporter.theme is unsupported.');
+  }
+  assertReporterFields(configuration.reporter?.visibleFields);
+  assertEvidence(configuration.evidence);
+  assertApplicationMetadata(configuration.application?.name);
+  assertCustomContext(configuration.customContext);
+  assertWorkspacePolicy(configuration.workspacePolicy);
+}
+
+function assertJavaScriptCrashCapture(
+  value: CrumbJavaScriptCrashCaptureOptions | undefined
+): void {
+  if (value === undefined) return;
+  assertPositiveInteger(
+    value.maximumBreadcrumbs,
+    'diagnostics.javascriptCrashCapture.maximumBreadcrumbs'
+  );
+  assertPositiveInteger(
+    value.maximumBreadcrumbBytes,
+    'diagnostics.javascriptCrashCapture.maximumBreadcrumbBytes'
+  );
+  if (value.maximumBreadcrumbs !== undefined && value.maximumBreadcrumbs > 50) {
+    throw new TypeError(
+      'Crumb diagnostics.javascriptCrashCapture.maximumBreadcrumbs must be at most 50.'
+    );
+  }
+  if (
+    value.maximumBreadcrumbBytes !== undefined &&
+    value.maximumBreadcrumbBytes > 65_536
+  ) {
+    throw new TypeError(
+      'Crumb diagnostics.javascriptCrashCapture.maximumBreadcrumbBytes must be at most 65536.'
+    );
+  }
+}
+
+function assertReporterFields(value: readonly string[] | undefined): void {
+  if (value === undefined) return;
+  if (
+    new Set(value).size !== value.length ||
+    value.some((field) => !['category', 'description'].includes(field)) ||
+    !value.includes('description')
+  ) {
+    throw new TypeError(
+      'Crumb reporter.visibleFields must contain unique supported fields including description.'
+    );
+  }
+}
+
+function assertEvidence(value: readonly string[] | undefined): void {
+  if (value === undefined) return;
+  const supported = [
+    'screenshot',
+    'performance',
+    'network',
+    'logs',
+    'thread_stacks',
+    'health_check',
+    'custom_context',
+  ];
+  if (
+    new Set(value).size !== value.length ||
+    value.some((item) => !supported.includes(item))
+  ) {
+    throw new TypeError(
+      'Crumb evidence must contain unique supported categories.'
+    );
+  }
+}
+
+function assertApplicationMetadata(value: string | undefined): void {
+  if (value === undefined) return;
+  if (
+    typeof value !== 'string' ||
+    !value.trim() ||
+    value.length > 256 ||
+    hasControlCharacters(value)
+  ) {
+    throw new TypeError(
+      'Crumb application.name must be printable and at most 256 characters.'
+    );
+  }
+}
+
+function assertCustomContext(value: CrumbConfiguration['customContext']): void {
+  if (value === undefined) return;
+  const allowedKeys = value.allowedKeys ?? [];
+  const values = value.values ?? {};
+  if (
+    !Array.isArray(allowedKeys) ||
+    new Set(allowedKeys).size !== allowedKeys.length ||
+    allowedKeys.length > 16 ||
+    allowedKeys.some((key) => !isValidContextKey(key))
+  ) {
+    throw new TypeError(
+      'Crumb customContext.allowedKeys contains an invalid key.'
+    );
+  }
+  if (values === null || typeof values !== 'object' || Array.isArray(values)) {
+    throw new TypeError('Crumb customContext.values must be a string map.');
+  }
+  const entries = Object.entries(values);
+  if (
+    entries.length > 16 ||
+    entries.some(
+      ([key, item]) => !isValidContextKey(key) || typeof item !== 'string'
+    )
+  ) {
+    throw new TypeError(
+      'Crumb customContext.values must contain bounded string values.'
+    );
+  }
+}
+
+function assertWorkspacePolicy(
+  value: CrumbConfiguration['workspacePolicy']
+): void {
+  if (value === undefined) return;
+  assertPositiveInteger(value.timeoutMs, 'workspacePolicy.timeoutMs');
+  if (
+    value.timeoutMs !== undefined &&
+    (value.timeoutMs < 250 || value.timeoutMs > 5000)
+  ) {
+    throw new TypeError(
+      'Crumb workspacePolicy.timeoutMs must be between 250 and 5000.'
+    );
+  }
+  if (value.url === undefined) return;
+  let url: WorkspacePolicyUrl;
+  try {
+    url = new URL(value.url) as unknown as WorkspacePolicyUrl;
+  } catch {
+    throw new TypeError(
+      'Crumb workspacePolicy.url must be a valid HTTP or HTTPS URL.'
+    );
+  }
+  if (
+    !['http:', 'https:'].includes(url.protocol) ||
+    url.username ||
+    url.password ||
+    url.search ||
+    url.hash
+  ) {
+    throw new TypeError(
+      'Crumb workspacePolicy.url must be an HTTP or HTTPS URL without credentials or query values.'
+    );
+  }
+}
+
+interface WorkspacePolicyUrl {
+  protocol: string;
+  username: string;
+  password: string;
+  search: string;
+  hash: string;
+}
+
+function isValidContextKey(value: unknown): value is string {
+  return (
+    typeof value === 'string' &&
+    value.length <= 64 &&
+    /^[A-Za-z][A-Za-z0-9_.-]*$/.test(value)
+  );
+}
+
+function hasControlCharacters(value: string): boolean {
+  return [...value].some(
+    (character) => character < ' ' || character === '\u007f'
+  );
 }
 
 function assertPositiveInteger(value: number | undefined, field: string): void {
@@ -103,6 +317,9 @@ function assertPositiveInteger(value: number | undefined, field: string): void {
 }
 
 const Crumb = Object.freeze({
+  setScreen,
+  trackReactNavigation,
+  useExpoRouterScreen,
   start,
   installReporter,
   show,