@crumbsdk/react-native 0.0.1-rc.3

package/android/src/main/java/com/margelo/nitro/crumbsdk/reactnative/CrumbReactNative.kt

@@ -0,0 +1,228 @@
+package com.margelo.nitro.crumbsdk.reactnative
+
+import android.app.Application
+import android.os.Build
+import com.facebook.react.bridge.UiThreadUtil
+import com.margelo.nitro.NitroModules
+import com.margelo.nitro.core.Promise
+import dev.crumb.core.Crumb
+import dev.crumb.core.CrumbCaptureOptions
+import dev.crumb.core.CrumbConfiguration
+import dev.crumb.core.CrumbDiagnosticsOptions
+import dev.crumb.core.CrumbInvocation
+import dev.crumb.core.CrumbLogEntry
+import dev.crumb.core.CrumbLogLevel
+import dev.crumb.core.CrumbLogOptions
+import dev.crumb.core.CrumbLogProvider
+import dev.crumb.core.CrumbPrivacyOptions
+import dev.crumb.core.CrumbRelease
+import dev.crumb.core.CrumbUploadOptions
+import dev.crumb.ui.CrumbReporter
+import org.json.JSONObject
+
+class CrumbReactNative : HybridCrumbReactNativeSpec() {
+    private val logBuffer = ReactNativeLogBuffer()
+
+    override fun start(configurationJson: String) {
+        val context = requireNotNull(NitroModules.applicationContext) {
+            "React Native is not ready. Call Crumb.start after the app has mounted."
+        }
+        val payload = JSONObject(configurationJson)
+        val release = payload.optJSONObject("release") ?: JSONObject()
+        val diagnostics = payload.optJSONObject("diagnostics")
+        val logs = diagnostics?.optJSONObject("logs")
+        val packageInfo = context.packageManager.getPackageInfo(context.packageName, 0)
+        val nativeBuild = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+            packageInfo.longVersionCode.toString()
+        } else {
+            @Suppress("DEPRECATION")
+            packageInfo.versionCode.toString()
+        }
+        val maximumEntries = logs?.optionalInt("maximumEntries") ?: 200
+        val maximumBytes = logs?.optionalInt("maximumBytes") ?: 65_536
+        val lookbackMillis = logs?.optionalLong("lookbackMs") ?: 60_000L
+
+        logBuffer.configure(
+            lookbackMillis = lookbackMillis,
+            maximumEntries = maximumEntries,
+            maximumBytes = maximumBytes,
+        )
+
+        Crumb.start(
+            CrumbConfiguration(
+                projectKey = payload.getString("projectKey"),
+                environment = payload.getString("environment"),
+                release = CrumbRelease(
+                    appVersion = release.optionalString("appVersion")
+                        ?: packageInfo.versionName
+                        ?: "0",
+                    nativeBuild = release.optionalString("nativeBuild") ?: nativeBuild,
+                    bundleVersion = release.optionalString("bundleVersion"),
+                ),
+                invocation = payload.invocations(),
+                capture = payload.captureOptions(),
+                diagnostics = CrumbDiagnosticsOptions(
+                    healthCheckUrl = diagnostics?.optionalString("healthCheckUrl"),
+                    timeoutMillis = diagnostics?.optionalLong("timeoutMs") ?: 2_000,
+                    logs = CrumbLogOptions(
+                        enabled = logs?.optionalBoolean("enabled") ?: true,
+                        lookbackMillis = lookbackMillis,
+                        maximumEntries = maximumEntries,
+                        maximumBytes = maximumBytes,
+                        provider = logBuffer,
+                    ),
+                ),
+                privacy = payload.privacyOptions(),
+                upload = CrumbUploadOptions(
+                    ingestionUrl = payload.optJSONObject("upload")
+                        ?.optionalString("ingestionUrl"),
+                ),
+            ),
+        )
+    }
+
+    override fun installReporter(): Promise<Boolean> {
+        val promise = Promise<Boolean>()
+        UiThreadUtil.runOnUiThread {
+            runCatching {
+                val context = requireNotNull(NitroModules.applicationContext)
+                val application = context.applicationContext as Application
+                CrumbReporter.install(application)
+            }.onSuccess(promise::resolve)
+                .onFailure(promise::reject)
+        }
+        return promise
+    }
+
+    override fun show(): Promise<Boolean> {
+        val promise = Promise<Boolean>()
+        UiThreadUtil.runOnUiThread {
+            runCatching {
+                val context = requireNotNull(NitroModules.applicationContext)
+                val activity = context.getCurrentActivity() ?: return@runCatching false
+                CrumbReporter.show(activity)
+            }.onSuccess(promise::resolve)
+                .onFailure(promise::reject)
+        }
+        return promise
+    }
+
+    override fun addLog(entryJson: String) {
+        val payload = JSONObject(entryJson)
+        logBuffer.append(
+            CrumbLogEntry(
+                timestampMillis = payload.getLong("timestampMs"),
+                level = payload.getString("level").toNativeLogLevel(),
+                source = payload.optString("source", "react-native"),
+                category = payload.optString("category", "javascript"),
+                message = payload.getString("message"),
+            ),
+        )
+    }
+
+    override fun clearLogs() {
+        logBuffer.clear()
+    }
+}
+
+private fun JSONObject.invocations(): Set<CrumbInvocation> {
+    val values = optJSONArray("invocation")
+        ?: return setOf(CrumbInvocation.SHAKE, CrumbInvocation.PROGRAMMATIC)
+    return buildSet {
+        for (index in 0 until values.length()) {
+            when (values.getString(index)) {
+                "shake" -> add(CrumbInvocation.SHAKE)
+                "programmatic" -> add(CrumbInvocation.PROGRAMMATIC)
+            }
+        }
+    }
+}
+
+private fun JSONObject.captureOptions(): CrumbCaptureOptions {
+    val capture = optJSONObject("capture") ?: return CrumbCaptureOptions()
+    return CrumbCaptureOptions(
+        screenshot = capture.optionalBoolean("screenshot") ?: true,
+        maximumScreenshotDimension = capture.optionalInt("maximumScreenshotDimension") ?: 2_048,
+        maximumScreenshotBytes = capture.optionalInt("maximumScreenshotBytes") ?: 5_242_880,
+    )
+}
+
+private fun JSONObject.privacyOptions(): CrumbPrivacyOptions {
+    val privacy = optJSONObject("privacy") ?: return CrumbPrivacyOptions()
+    return CrumbPrivacyOptions(
+        maskAllTextInputs = privacy.optionalBoolean("maskAllTextInputs") ?: true,
+        maskScreenshotsBeforeUpload = privacy.optionalBoolean("maskScreenshotsBeforeUpload") ?: true,
+    )
+}
+
+private fun JSONObject.optionalString(name: String): String? =
+    if (has(name) && !isNull(name)) getString(name) else null
+
+private fun JSONObject.optionalBoolean(name: String): Boolean? =
+    if (has(name) && !isNull(name)) getBoolean(name) else null
+
+private fun JSONObject.optionalInt(name: String): Int? =
+    if (has(name) && !isNull(name)) getInt(name) else null
+
+private fun JSONObject.optionalLong(name: String): Long? =
+    if (has(name) && !isNull(name)) getLong(name) else null
+
+private fun String.toNativeLogLevel(): CrumbLogLevel = when (this) {
+    "debug" -> CrumbLogLevel.DEBUG
+    "info" -> CrumbLogLevel.INFO
+    "notice" -> CrumbLogLevel.NOTICE
+    "warning" -> CrumbLogLevel.WARNING
+    "error" -> CrumbLogLevel.ERROR
+    "fault" -> CrumbLogLevel.FAULT
+    else -> CrumbLogLevel.INFO
+}
+
+private class ReactNativeLogBuffer : CrumbLogProvider {
+    private val lock = Any()
+    private val entries = ArrayDeque<CrumbLogEntry>()
+    private var lookbackMillis = 60_000L
+    private var maximumEntries = 200
+    private var maximumBytes = 65_536
+
+    fun configure(
+        lookbackMillis: Long,
+        maximumEntries: Int,
+        maximumBytes: Int,
+    ) = synchronized(lock) {
+        this.lookbackMillis = lookbackMillis
+        this.maximumEntries = maximumEntries
+        this.maximumBytes = maximumBytes
+        prune(System.currentTimeMillis())
+    }
+
+    fun append(entry: CrumbLogEntry) = synchronized(lock) {
+        entries.addLast(entry)
+        prune(System.currentTimeMillis())
+    }
+
+    fun clear() = synchronized(lock) {
+        entries.clear()
+    }
+
+    override fun recentLogs(): List<CrumbLogEntry> = synchronized(lock) {
+        prune(System.currentTimeMillis())
+        entries.toList()
+    }
+
+    private fun prune(now: Long) {
+        val earliest = now - lookbackMillis
+        while (entries.firstOrNull()?.timestampMillis?.let { it < earliest } == true) {
+            entries.removeFirst()
+        }
+        while (entries.size > maximumEntries || byteCount() > maximumBytes) {
+            entries.removeFirstOrNull()
+        }
+    }
+
+    private fun byteCount(): Int = entries.sumOf { entry ->
+        entry.source.toByteArray().size +
+            entry.category.toByteArray().size +
+            entry.message.toByteArray().size +
+            32
+    }
+}

package/android/src/main/java/com/margelo/nitro/crumbsdk/reactnative/ReactNativePackage.kt

@@ -0,0 +1,22 @@
+package com.margelo.nitro.crumbsdk.reactnative
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class ReactNativePackage : BaseReactPackage() {
+    override fun getModule(
+        name: String,
+        reactContext: ReactApplicationContext,
+    ): NativeModule? = null
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider =
+        ReactModuleInfoProvider { HashMap() }
+
+    companion object {
+        init {
+            System.loadLibrary("crumbsdk_reactnative")
+        }
+    }
+}

package/ios/CrumbReactNative.swift

@@ -0,0 +1,283 @@
+import CrumbCore
+import CrumbUI
+import Foundation
+import NitroModules
+
+final class CrumbReactNative: HybridCrumbReactNativeSpec {
+    private let decoder = JSONDecoder()
+    private let logBuffer = ReactNativeLogBuffer()
+
+    func start(configurationJson: String) throws {
+        let data = Data(configurationJson.utf8)
+        let payload = try decoder.decode(ConfigurationPayload.self, from: data)
+        let bundle = Bundle.main
+        let appVersion = payload.release?.appVersion
+            ?? bundle.object(forInfoDictionaryKey: "CFBundleShortVersionString") as? String
+            ?? "0"
+        let nativeBuild = payload.release?.nativeBuild
+            ?? bundle.object(forInfoDictionaryKey: "CFBundleVersion") as? String
+            ?? "0"
+        let logOptions = payload.diagnostics?.logs ?? .init()
+
+        logBuffer.configure(
+            lookback: logOptions.lookbackMs.map { TimeInterval(milliseconds: $0) } ?? 60,
+            maximumEntries: logOptions.maximumEntries ?? 200,
+            maximumBytes: logOptions.maximumBytes ?? 65_536
+        )
+
+        try Crumb.start(
+            CrumbConfiguration(
+                projectKey: payload.projectKey,
+                environment: payload.environment,
+                release: CrumbRelease(
+                    appVersion: appVersion,
+                    nativeBuild: nativeBuild,
+                    bundleVersion: payload.release?.bundleVersion
+                ),
+                invocation: Set(
+                    (payload.invocation ?? [.shake, .programmatic]).map(\.native)
+                ),
+                capture: CrumbCaptureOptions(
+                    screenshot: payload.capture?.screenshot ?? true,
+                    maximumScreenshotDimension:
+                        payload.capture?.maximumScreenshotDimension ?? 2_048,
+                    maximumScreenshotBytes:
+                        payload.capture?.maximumScreenshotBytes ?? 5_242_880
+                ),
+                diagnostics: CrumbDiagnosticsOptions(
+                    healthCheckURL: try payload.diagnostics?.healthCheckURL(),
+                    timeout: payload.diagnostics?.timeoutMs
+                        .map { TimeInterval(milliseconds: $0) } ?? 2,
+                    logs: CrumbLogOptions(
+                        enabled: logOptions.enabled ?? true,
+                        lookback: logOptions.lookbackMs
+                            .map { TimeInterval(milliseconds: $0) } ?? 60,
+                        maximumEntries: logOptions.maximumEntries ?? 200,
+                        maximumBytes: logOptions.maximumBytes ?? 65_536,
+                        provider: logBuffer
+                    )
+                ),
+                privacy: CrumbPrivacyOptions(
+                    maskAllTextInputs: payload.privacy?.maskAllTextInputs ?? true,
+                    maskScreenshotsBeforeUpload:
+                        payload.privacy?.maskScreenshotsBeforeUpload ?? true
+                ),
+                upload: CrumbUploadOptions(
+                    ingestionURL: try payload.upload?.ingestionURL()
+                )
+            )
+        )
+    }
+
+    func installReporter() throws -> Promise<Bool> {
+        Promise.async { @MainActor in
+            Crumb.installReporter()
+        }
+    }
+
+    func show() throws -> Promise<Bool> {
+        Promise.async { @MainActor in
+            Crumb.show()
+        }
+    }
+
+    func addLog(entryJson: String) throws {
+        let data = Data(entryJson.utf8)
+        let entry = try decoder.decode(LogEntryPayload.self, from: data)
+        logBuffer.append(entry.native)
+    }
+
+    func clearLogs() throws {
+        logBuffer.clear()
+    }
+}
+
+private struct ConfigurationPayload: Decodable {
+    let projectKey: String
+    let environment: String
+    let release: ReleasePayload?
+    let invocation: [InvocationPayload]?
+    let capture: CapturePayload?
+    let diagnostics: DiagnosticsPayload?
+    let privacy: PrivacyPayload?
+    let upload: UploadPayload?
+}
+
+private struct ReleasePayload: Decodable {
+    let appVersion: String?
+    let nativeBuild: String?
+    let bundleVersion: String?
+}
+
+private enum InvocationPayload: String, Decodable {
+    case shake
+    case programmatic
+
+    var native: CrumbInvocation {
+        switch self {
+        case .shake: .shake
+        case .programmatic: .programmatic
+        }
+    }
+}
+
+private struct CapturePayload: Decodable {
+    let screenshot: Bool?
+    let maximumScreenshotDimension: Int?
+    let maximumScreenshotBytes: Int?
+}
+
+private struct DiagnosticsPayload: Decodable {
+    let healthCheckUrl: String?
+    let timeoutMs: Int?
+    let logs: LogOptionsPayload?
+
+    func healthCheckURL() throws -> URL? {
+        guard let healthCheckUrl else { return nil }
+        guard let url = URL(string: healthCheckUrl) else {
+            throw BridgeConfigurationError.invalidURL("healthCheckUrl")
+        }
+        return url
+    }
+}
+
+private struct LogOptionsPayload: Decodable {
+    let enabled: Bool?
+    let lookbackMs: Int?
+    let maximumEntries: Int?
+    let maximumBytes: Int?
+
+    init(
+        enabled: Bool? = nil,
+        lookbackMs: Int? = nil,
+        maximumEntries: Int? = nil,
+        maximumBytes: Int? = nil
+    ) {
+        self.enabled = enabled
+        self.lookbackMs = lookbackMs
+        self.maximumEntries = maximumEntries
+        self.maximumBytes = maximumBytes
+    }
+}
+
+private struct PrivacyPayload: Decodable {
+    let maskAllTextInputs: Bool?
+    let maskScreenshotsBeforeUpload: Bool?
+}
+
+private struct UploadPayload: Decodable {
+    let ingestionUrl: String?
+
+    func ingestionURL() throws -> URL? {
+        guard let ingestionUrl else { return nil }
+        guard let url = URL(string: ingestionUrl) else {
+            throw BridgeConfigurationError.invalidURL("ingestionUrl")
+        }
+        return url
+    }
+}
+
+private enum BridgeConfigurationError: Error {
+    case invalidURL(String)
+}
+
+private struct LogEntryPayload: Decodable {
+    let timestampMs: Int64
+    let level: String
+    let source: String
+    let category: String
+    let message: String
+
+    var native: CrumbLogEntry {
+        CrumbLogEntry(
+            timestamp: Date(timeIntervalSince1970: TimeInterval(timestampMs) / 1_000),
+            level: level.nativeLogLevel,
+            source: source,
+            category: category,
+            message: message
+        )
+    }
+}
+
+private extension String {
+    var nativeLogLevel: CrumbLogLevel {
+        switch self {
+        case "debug": .debug
+        case "notice": .notice
+        case "warning": .warning
+        case "error": .error
+        case "fault": .fault
+        default: .info
+        }
+    }
+}
+
+private final class ReactNativeLogBuffer: CrumbLogProvider, @unchecked Sendable {
+    private let lock = NSLock()
+    private var entries: [CrumbLogEntry] = []
+    private var lookback: TimeInterval = 60
+    private var maximumEntries = 200
+    private var maximumBytes = 65_536
+
+    func configure(
+        lookback: TimeInterval,
+        maximumEntries: Int,
+        maximumBytes: Int
+    ) {
+        withLock {
+            self.lookback = lookback
+            self.maximumEntries = maximumEntries
+            self.maximumBytes = maximumBytes
+            prune(now: Date())
+        }
+    }
+
+    func append(_ entry: CrumbLogEntry) {
+        withLock {
+            entries.append(entry)
+            prune(now: Date())
+        }
+    }
+
+    func clear() {
+        withLock {
+            entries.removeAll(keepingCapacity: false)
+        }
+    }
+
+    func recentLogs() throws -> [CrumbLogEntry] {
+        withLock {
+            prune(now: Date())
+            return entries
+        }
+    }
+
+    private func prune(now: Date) {
+        let earliest = now.addingTimeInterval(-lookback)
+        entries.removeAll { $0.timestamp < earliest }
+        while entries.count > maximumEntries || byteCount(entries) > maximumBytes {
+            entries.removeFirst()
+        }
+    }
+
+    private func byteCount(_ entries: [CrumbLogEntry]) -> Int {
+        entries.reduce(into: 0) { total, entry in
+            total += entry.source.utf8.count
+                + entry.category.utf8.count
+                + entry.message.utf8.count
+                + 32
+        }
+    }
+
+    private func withLock<Result>(_ action: () throws -> Result) rethrows -> Result {
+        lock.lock()
+        defer { lock.unlock() }
+        return try action()
+    }
+}
+
+private extension TimeInterval {
+    init(milliseconds: Int) {
+        self = TimeInterval(milliseconds) / 1_000
+    }
+}

package/lib/module/CrumbReactNative.nitro.js

@@ -0,0 +1,4 @@
+"use strict";
+
+export {};
+//# sourceMappingURL=CrumbReactNative.nitro.js.map

package/lib/module/CrumbReactNative.nitro.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sourceRoot":"../../src","sources":["CrumbReactNative.nitro.ts"],"mappings":"","ignoreList":[]}

package/lib/module/NativeCrumbReactNative.js

@@ -0,0 +1,5 @@
+"use strict";
+
+import { NitroModules } from 'react-native-nitro-modules';
+export default NitroModules.createHybridObject('CrumbReactNative');
+//# sourceMappingURL=NativeCrumbReactNative.js.map

package/lib/module/NativeCrumbReactNative.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NitroModules","createHybridObject"],"sourceRoot":"../../src","sources":["NativeCrumbReactNative.ts"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,4BAA4B;AAGzD,eAAeA,YAAY,CAACC,kBAAkB,CAC5C,kBACF,CAAC","ignoreList":[]}

package/lib/module/NativeCrumbReactNative.web.js

@@ -0,0 +1,18 @@
+"use strict";
+
+const unsupportedMessage = 'Crumb requires an iOS or Android native build and is unavailable on web or in Expo Go.';
+const unsupportedModule = {
+  name: 'CrumbReactNative',
+  dispose: () => undefined,
+  equals: () => false,
+  toString: () => '[HybridObject CrumbReactNative unavailable on web]',
+  start: () => {
+    throw new Error(unsupportedMessage);
+  },
+  installReporter: () => Promise.resolve(false),
+  show: () => Promise.resolve(false),
+  addLog: () => undefined,
+  clearLogs: () => undefined
+};
+export default unsupportedModule;
+//# sourceMappingURL=NativeCrumbReactNative.web.js.map

package/lib/module/NativeCrumbReactNative.web.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["unsupportedMessage","unsupportedModule","name","dispose","undefined","equals","toString","start","Error","installReporter","Promise","resolve","show","addLog","clearLogs"],"sourceRoot":"../../src","sources":["NativeCrumbReactNative.web.ts"],"mappings":";;AAEA,MAAMA,kBAAkB,GACtB,wFAAwF;AAE1F,MAAMC,iBAAmC,GAAG;EAC1CC,IAAI,EAAE,kBAAkB;EACxBC,OAAO,EAAEA,CAAA,KAAMC,SAAS;EACxBC,MAAM,EAAEA,CAAA,KAAM,KAAK;EACnBC,QAAQ,EAAEA,CAAA,KAAM,oDAAoD;EACpEC,KAAK,EAAEA,CAAA,KAAM;IACX,MAAM,IAAIC,KAAK,CAACR,kBAAkB,CAAC;EACrC,CAAC;EACDS,eAAe,EAAEA,CAAA,KAAMC,OAAO,CAACC,OAAO,CAAC,KAAK,CAAC;EAC7CC,IAAI,EAAEA,CAAA,KAAMF,OAAO,CAACC,OAAO,CAAC,KAAK,CAAC;EAClCE,MAAM,EAAEA,CAAA,KAAMT,SAAS;EACvBU,SAAS,EAAEA,CAAA,KAAMV;AACnB,CAAC;AAED,eAAeH,iBAAiB","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,60 @@
+"use strict";
+
+import NativeCrumbReactNative from './NativeCrumbReactNative';
+import { clearLogs, configureLogBuffer, disableConsoleCapture, enableConsoleCapture, markNativeStarted, writeLog } from "./log-buffer.js";
+export async function start(configuration) {
+  validateConfiguration(configuration);
+  const logOptions = configuration.diagnostics?.logs;
+  configureLogBuffer(logOptions);
+  NativeCrumbReactNative.start(JSON.stringify(configuration));
+  markNativeStarted();
+  if (logOptions?.captureConsole) {
+    enableConsoleCapture();
+  } else {
+    disableConsoleCapture();
+  }
+}
+export function installReporter() {
+  return NativeCrumbReactNative.installReporter();
+}
+export function show() {
+  return NativeCrumbReactNative.show();
+}
+export function log(level, message, metadata) {
+  if (!message.trim()) {
+    throw new TypeError('Crumb.log message must not be empty.');
+  }
+  writeLog(level, message, metadata);
+}
+export { clearLogs, disableConsoleCapture, enableConsoleCapture };
+function validateConfiguration(configuration) {
+  if (!configuration.projectKey?.trim()) {
+    throw new TypeError('Crumb projectKey must not be empty.');
+  }
+  if (!configuration.environment?.trim()) {
+    throw new TypeError('Crumb environment must not be empty.');
+  }
+  assertPositiveInteger(configuration.capture?.maximumScreenshotDimension, 'capture.maximumScreenshotDimension');
+  assertPositiveInteger(configuration.capture?.maximumScreenshotBytes, 'capture.maximumScreenshotBytes');
+  assertPositiveInteger(configuration.diagnostics?.timeoutMs, 'diagnostics.timeoutMs');
+  assertPositiveInteger(configuration.diagnostics?.logs?.lookbackMs, 'diagnostics.logs.lookbackMs');
+  assertPositiveInteger(configuration.diagnostics?.logs?.maximumEntries, 'diagnostics.logs.maximumEntries');
+  assertPositiveInteger(configuration.diagnostics?.logs?.maximumBytes, 'diagnostics.logs.maximumBytes');
+}
+function assertPositiveInteger(value, field) {
+  if (value === undefined) return;
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new TypeError(`Crumb ${field} must be a positive integer.`);
+  }
+}
+const Crumb = Object.freeze({
+  start,
+  installReporter,
+  show,
+  log,
+  clearLogs,
+  enableConsoleCapture,
+  disableConsoleCapture
+});
+export default Crumb;
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["NativeCrumbReactNative","clearLogs","configureLogBuffer","disableConsoleCapture","enableConsoleCapture","markNativeStarted","writeLog","start","configuration","validateConfiguration","logOptions","diagnostics","logs","JSON","stringify","captureConsole","installReporter","show","log","level","message","metadata","trim","TypeError","projectKey","environment","assertPositiveInteger","capture","maximumScreenshotDimension","maximumScreenshotBytes","timeoutMs","lookbackMs","maximumEntries","maximumBytes","value","field","undefined","Number","isSafeInteger","Crumb","Object","freeze"],"sourceRoot":"../../src","sources":["index.ts"],"mappings":";;AAAA,OAAOA,sBAAsB,MAAM,0BAA0B;AAC7D,SACEC,SAAS,EACTC,kBAAkB,EAClBC,qBAAqB,EACrBC,oBAAoB,EACpBC,iBAAiB,EACjBC,QAAQ,QACH,iBAAc;AAoBrB,OAAO,eAAeC,KAAKA,CAACC,aAAiC,EAAiB;EAC5EC,qBAAqB,CAACD,aAAa,CAAC;EACpC,MAAME,UAAU,GAAGF,aAAa,CAACG,WAAW,EAAEC,IAAI;EAClDV,kBAAkB,CAACQ,UAAU,CAAC;EAC9BV,sBAAsB,CAACO,KAAK,CAACM,IAAI,CAACC,SAAS,CAACN,aAAa,CAAC,CAAC;EAC3DH,iBAAiB,CAAC,CAAC;EAEnB,IAAIK,UAAU,EAAEK,cAAc,EAAE;IAC9BX,oBAAoB,CAAC,CAAC;EACxB,CAAC,MAAM;IACLD,qBAAqB,CAAC,CAAC;EACzB;AACF;AAEA,OAAO,SAASa,eAAeA,CAAA,EAAqB;EAClD,OAAOhB,sBAAsB,CAACgB,eAAe,CAAC,CAAC;AACjD;AAEA,OAAO,SAASC,IAAIA,CAAA,EAAqB;EACvC,OAAOjB,sBAAsB,CAACiB,IAAI,CAAC,CAAC;AACtC;AAEA,OAAO,SAASC,GAAGA,CACjBC,KAAoB,EACpBC,OAAe,EACfC,QAA2B,EACrB;EACN,IAAI,CAACD,OAAO,CAACE,IAAI,CAAC,CAAC,EAAE;IACnB,MAAM,IAAIC,SAAS,CAAC,sCAAsC,CAAC;EAC7D;EACAjB,QAAQ,CAACa,KAAK,EAAEC,OAAO,EAAEC,QAAQ,CAAC;AACpC;AAEA,SAASpB,SAAS,EAAEE,qBAAqB,EAAEC,oBAAoB;AAE/D,SAASK,qBAAqBA,CAACD,aAAiC,EAAQ;EACtE,IAAI,CAACA,aAAa,CAACgB,UAAU,EAAEF,IAAI,CAAC,CAAC,EAAE;IACrC,MAAM,IAAIC,SAAS,CAAC,qCAAqC,CAAC;EAC5D;EACA,IAAI,CAACf,aAAa,CAACiB,WAAW,EAAEH,IAAI,CAAC,CAAC,EAAE;IACtC,MAAM,IAAIC,SAAS,CAAC,sCAAsC,CAAC;EAC7D;EAEAG,qBAAqB,CACnBlB,aAAa,CAACmB,OAAO,EAAEC,0BAA0B,EACjD,oCACF,CAAC;EACDF,qBAAqB,CACnBlB,aAAa,CAACmB,OAAO,EAAEE,sBAAsB,EAC7C,gCACF,CAAC;EACDH,qBAAqB,CACnBlB,aAAa,CAACG,WAAW,EAAEmB,SAAS,EACpC,uBACF,CAAC;EACDJ,qBAAqB,CACnBlB,aAAa,CAACG,WAAW,EAAEC,IAAI,EAAEmB,UAAU,EAC3C,6BACF,CAAC;EACDL,qBAAqB,CACnBlB,aAAa,CAACG,WAAW,EAAEC,IAAI,EAAEoB,cAAc,EAC/C,iCACF,CAAC;EACDN,qBAAqB,CACnBlB,aAAa,CAACG,WAAW,EAAEC,IAAI,EAAEqB,YAAY,EAC7C,+BACF,CAAC;AACH;AAEA,SAASP,qBAAqBA,CAACQ,KAAyB,EAAEC,KAAa,EAAQ;EAC7E,IAAID,KAAK,KAAKE,SAAS,EAAE;EACzB,IAAI,CAACC,MAAM,CAACC,aAAa,CAACJ,KAAK,CAAC,IAAIA,KAAK,IAAI,CAAC,EAAE;IAC9C,MAAM,IAAIX,SAAS,CAAC,SAASY,KAAK,8BAA8B,CAAC;EACnE;AACF;AAEA,MAAMI,KAAK,GAAGC,MAAM,CAACC,MAAM,CAAC;EAC1BlC,KAAK;EACLS,eAAe;EACfC,IAAI;EACJC,GAAG;EACHjB,SAAS;EACTG,oBAAoB;EACpBD;AACF,CAAC,CAAC;AAEF,eAAeoC,KAAK","ignoreList":[]}