@booleanmaths/booleanmaths-rn-sdk 0.1.0

package/android/src/main/java/com/booleanmathsrnsdk/BooleanmathsRnSdkModule.kt

@@ -0,0 +1,126 @@
+package com.booleanmathsrnsdk
+
+import android.util.Log
+import com.booleanmaths.sdk.BooleanMathsSDK
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
+
+class BooleanmathsRnSdkModule(reactContext: ReactApplicationContext) :
+  NativeBooleanmathsRnSdkSpec(reactContext) {
+
+  override fun initializeSdk(apiKey: String, pixelId: String) {
+    safely("initialize") {
+      // Stamp the wrapper identity *before* initialize() so the automatic
+      // `app_opened` and `FirstOpen` events that the native SDK tracks during
+      // initialization already carry wrapper_type / wrapper_version.
+      applyWrapperConfig()
+
+      BooleanMathsSDK.initialize(
+        reactApplicationContext.applicationContext,
+        apiKey,
+        pixelId
+      )
+
+      // ...and again afterwards, because the native SDK can only persist the
+      // wrapper config to SharedPreferences once it holds an application
+      // context, which it only acquires inside initialize().
+      applyWrapperConfig()
+
+      // The native SDK registers its ActivityLifecycleCallbacks from within
+      // initialize(). In a React Native app that happens long after
+      // MainActivity's onActivityCreated has fired, so the intent that
+      // cold-started the app is never seen by those callbacks. Forward it
+      // explicitly here so a deep link that launched the app is attributed.
+      forwardCurrentIntent()
+    }
+  }
+
+  override fun trackEvent(name: String, properties: ReadableMap?) {
+    safely("trackEvent") {
+      BooleanMathsSDK.trackEvent(name, properties.toEventProperties())
+    }
+  }
+
+  override fun handleNotificationIntent() {
+    safely("handleNotificationIntent") { forwardCurrentIntent() }
+  }
+
+  override fun getHelloMessage(): String = BooleanMathsSDK.getHelloMessage()
+
+  private fun applyWrapperConfig() {
+    BooleanMathsSDK.setWrapperConfig(
+      BuildConfig.WRAPPER_TYPE,
+      BuildConfig.WRAPPER_VERSION
+    )
+  }
+
+  private fun forwardCurrentIntent() {
+    val intent = reactApplicationContext.currentActivity?.intent
+
+    if (intent == null) {
+      Log.d(TAG, "No current Activity intent available to forward.")
+      return
+    }
+
+    // The native SDK de-duplicates intents it has already processed, so
+    // calling this more than once for the same intent is safe.
+    BooleanMathsSDK.handleNotificationIntent(intent)
+  }
+
+  /**
+   * Analytics must never take the host app down. Any failure is logged and
+   * swallowed rather than surfaced to JS as a thrown exception.
+   */
+  private inline fun safely(operation: String, block: () -> Unit) {
+    try {
+      block()
+    } catch (throwable: Throwable) {
+      Log.e(TAG, "BooleanMaths $operation failed", throwable)
+    }
+  }
+
+  companion object {
+    const val NAME = NativeBooleanmathsRnSdkSpec.NAME
+    private const val TAG = "BooleanmathsRnSdk"
+
+    /** Matches JavaScript's Number.MAX_SAFE_INTEGER. */
+    private const val MAX_SAFE_INTEGER = 9007199254740991.0
+
+    private fun ReadableMap?.toEventProperties(): Map<String, Any> =
+      if (this == null) emptyMap() else normalizeMap(toHashMap())
+
+    /**
+     * Null-valued keys are dropped: the native SDK serializes properties with
+     * Gson, which omits null map values anyway, so this changes nothing about
+     * the emitted JSON.
+     */
+    private fun normalizeMap(source: Map<*, *>): Map<String, Any> {
+      val result = LinkedHashMap<String, Any>(source.size)
+
+      for ((key, value) in source) {
+        val normalized = normalizeValue(value) ?: continue
+        result[key.toString()] = normalized
+      }
+
+      return result
+    }
+
+    private fun normalizeValue(value: Any?): Any? = when (value) {
+      null -> null
+      // React Native passes every JS number across the bridge as a Double, so
+      // without this an integral value would serialize as `3.0` instead of `3`.
+      is Double -> value.toWholeNumberOrSelf()
+      is Map<*, *> -> normalizeMap(value)
+      // Nulls are preserved inside lists — dropping them would shift indices.
+      is Iterable<*> -> value.map { normalizeValue(it) }
+      else -> value
+    }
+
+    private fun Double.toWholeNumberOrSelf(): Any =
+      if (isFinite() && this % 1.0 == 0.0 && kotlin.math.abs(this) <= MAX_SAFE_INTEGER) {
+        toLong()
+      } else {
+        this
+      }
+  }
+}

package/android/src/main/java/com/booleanmathsrnsdk/BooleanmathsRnSdkPackage.kt

@@ -0,0 +1,31 @@
+package com.booleanmathsrnsdk
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class BooleanmathsRnSdkPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == BooleanmathsRnSdkModule.NAME) {
+      BooleanmathsRnSdkModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider() = ReactModuleInfoProvider {
+    mapOf(
+      BooleanmathsRnSdkModule.NAME to ReactModuleInfo(
+        name = BooleanmathsRnSdkModule.NAME,
+        className = BooleanmathsRnSdkModule.NAME,
+        canOverrideExistingModule = false,
+        needsEagerInit = false,
+        isCxxModule = false,
+        isTurboModule = true
+      )
+    )
+  }
+}

package/ios/BooleanmathsRnSdk.h

@@ -0,0 +1,20 @@
+#import <BooleanmathsRnSdkSpec/BooleanmathsRnSdkSpec.h>
+
+/**
+ * iOS no-op implementation of the BooleanMaths SDK.
+ *
+ * There is no native BooleanMaths iOS SDK published yet (the native SDK ships
+ * for Android only, as `com.booleanmaths:bm-sdk`). This class exists so that
+ * the TurboModule still resolves on iOS and every call degrades into a
+ * harmless no-op instead of crashing the host app.
+ *
+ * In practice these methods are never reached: the JavaScript layer gates on
+ * `Platform.OS` and returns before touching the bridge. They are implemented
+ * anyway as a backstop.
+ *
+ * When an iOS SDK becomes available, replace the bodies below and flip
+ * `SUPPORTED_PLATFORMS` in `src/BooleanMaths.native.tsx` to include 'ios'.
+ */
+@interface BooleanmathsRnSdk : NSObject <NativeBooleanmathsRnSdkSpec>
+
+@end

package/ios/BooleanmathsRnSdk.mm

@@ -0,0 +1,56 @@
+#import "BooleanmathsRnSdk.h"
+
+#import <React/RCTLog.h>
+
+@implementation BooleanmathsRnSdk
+
+/**
+ * Logs the "no iOS SDK" warning at most once per app launch so it is visible
+ * without flooding the console if something does call through.
+ */
+static void BMWarnUnsupportedOnce(void)
+{
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    RCTLogWarn(@"[@booleanmaths/booleanmaths-rn-sdk] The BooleanMaths native SDK is not available on iOS "
+               @"(Android only for now). All SDK calls are no-ops and no events will be "
+               @"tracked on this platform.");
+  });
+}
+
+- (void)initializeSdk:(NSString *)apiKey pixelId:(NSString *)pixelId
+{
+  BMWarnUnsupportedOnce();
+}
+
+- (void)trackEvent:(NSString *)name properties:(NSDictionary *)properties
+{
+  BMWarnUnsupportedOnce();
+}
+
+- (void)handleNotificationIntent
+{
+  // Android-only concept; nothing to do on iOS even once an iOS SDK exists.
+  BMWarnUnsupportedOnce();
+}
+
+- (NSString *)getHelloMessage
+{
+  BMWarnUnsupportedOnce();
+
+  // Deliberately not nil: the codegen spec declares a non-optional string.
+  return @"BooleanMaths SDK is not available on iOS";
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params
+{
+    return std::make_shared<facebook::react::NativeBooleanmathsRnSdkSpecJSI>(params);
+}
+
++ (NSString *)moduleName
+{
+  return @"BooleanmathsRnSdk";
+}
+
+@end

package/lib/module/BooleanMaths.js

@@ -0,0 +1,34 @@
+"use strict";
+
+/**
+ * Web (and any non-React-Native) build of the SDK.
+ *
+ * There is no BooleanMaths browser SDK behind this wrapper, so every method is
+ * a no-op. It exists so that shared code can import and call the SDK
+ * unconditionally without platform checks or bundler errors.
+ */
+let hasWarned = false;
+function warnOnce() {
+  if (hasWarned || typeof __DEV__ === 'undefined' || !__DEV__) {
+    return;
+  }
+  hasWarned = true;
+  console.warn('[@booleanmaths/booleanmaths-rn-sdk] The BooleanMaths SDK has no web implementation. ' + 'All SDK calls are no-ops on web and no events will be tracked. Gate your ' + 'calls on `BooleanMaths.isSupported` to silence this warning.');
+}
+export const BooleanMaths = {
+  isSupported: false,
+  initialize(_apiKey, _pixelId) {
+    warnOnce();
+  },
+  trackEvent(_name, _properties) {
+    warnOnce();
+  },
+  handleNotificationIntent() {
+    warnOnce();
+  },
+  getHelloMessage() {
+    warnOnce();
+    return null;
+  }
+};
+//# sourceMappingURL=BooleanMaths.js.map

package/lib/module/BooleanMaths.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["hasWarned","warnOnce","__DEV__","console","warn","BooleanMaths","isSupported","initialize","_apiKey","_pixelId","trackEvent","_name","_properties","handleNotificationIntent","getHelloMessage"],"sourceRoot":"../../src","sources":["BooleanMaths.tsx"],"mappings":";;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAIA,SAAS,GAAG,KAAK;AAErB,SAASC,QAAQA,CAAA,EAAG;EAClB,IAAID,SAAS,IAAI,OAAOE,OAAO,KAAK,WAAW,IAAI,CAACA,OAAO,EAAE;IAC3D;EACF;EAEAF,SAAS,GAAG,IAAI;EAEhBG,OAAO,CAACC,IAAI,CACV,sFAAsF,GACpF,2EAA2E,GAC3E,8DACJ,CAAC;AACH;AAEA,OAAO,MAAMC,YAA6B,GAAG;EAC3CC,WAAW,EAAE,KAAK;EAElBC,UAAUA,CAACC,OAAe,EAAEC,QAAgB,EAAQ;IAClDR,QAAQ,CAAC,CAAC;EACZ,CAAC;EAEDS,UAAUA,CAACC,KAAa,EAAEC,WAAyC,EAAQ;IACzEX,QAAQ,CAAC,CAAC;EACZ,CAAC;EAEDY,wBAAwBA,CAAA,EAAS;IAC/BZ,QAAQ,CAAC,CAAC;EACZ,CAAC;EAEDa,eAAeA,CAAA,EAAkB;IAC/Bb,QAAQ,CAAC,CAAC;IACV,OAAO,IAAI;EACb;AACF,CAAC","ignoreList":[]}

package/lib/module/BooleanMaths.native.js

@@ -0,0 +1,62 @@
+"use strict";
+
+import { Platform } from 'react-native';
+import NativeBooleanmathsRnSdk from "./NativeBooleanmathsRnSdk.js";
+/**
+ * The BooleanMaths native SDK currently ships for Android only. There is no
+ * iOS artifact yet, so on iOS every call below short-circuits and the SDK
+ * behaves as a silent no-op rather than crashing the app.
+ */
+const SUPPORTED_PLATFORMS = ['android'];
+const isPlatformSupported = SUPPORTED_PLATFORMS.includes(Platform.OS);
+
+/**
+ * Both conditions must hold: a platform we ship a native SDK for, and a native
+ * module that actually resolved. The second guards against a broken/incomplete
+ * native install.
+ */
+const isSupported = isPlatformSupported && NativeBooleanmathsRnSdk != null;
+let hasWarned = false;
+function warnOnce() {
+  if (hasWarned || !__DEV__) {
+    return;
+  }
+  hasWarned = true;
+  if (!isPlatformSupported) {
+    console.warn(`[@booleanmaths/booleanmaths-rn-sdk] The BooleanMaths native SDK is not available on ${Platform.OS} ` + '(Android only for now). All SDK calls are no-ops on this platform and no ' + 'events will be tracked. Gate your calls on `BooleanMaths.isSupported` to ' + 'silence this warning — see the README\'s "Platform support" section.');
+    return;
+  }
+  console.warn('[@booleanmaths/booleanmaths-rn-sdk] The native module could not be found on ' + `${Platform.OS}. Rebuild the app after installing the package (a Metro ` + 'reload is not enough), and on iOS run `pod install`. All SDK calls are ' + 'no-ops until this is fixed.');
+}
+export const BooleanMaths = {
+  isSupported,
+  initialize(apiKey, pixelId) {
+    if (!isSupported) {
+      warnOnce();
+      return;
+    }
+    NativeBooleanmathsRnSdk.initializeSdk(apiKey, pixelId);
+  },
+  trackEvent(name, properties = {}) {
+    if (!isSupported) {
+      warnOnce();
+      return;
+    }
+    NativeBooleanmathsRnSdk.trackEvent(name, properties);
+  },
+  handleNotificationIntent() {
+    if (!isSupported) {
+      warnOnce();
+      return;
+    }
+    NativeBooleanmathsRnSdk.handleNotificationIntent();
+  },
+  getHelloMessage() {
+    if (!isSupported) {
+      warnOnce();
+      return null;
+    }
+    return NativeBooleanmathsRnSdk.getHelloMessage();
+  }
+};
+//# sourceMappingURL=BooleanMaths.native.js.map

package/lib/module/BooleanMaths.native.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Platform","NativeBooleanmathsRnSdk","SUPPORTED_PLATFORMS","isPlatformSupported","includes","OS","isSupported","hasWarned","warnOnce","__DEV__","console","warn","BooleanMaths","initialize","apiKey","pixelId","initializeSdk","trackEvent","name","properties","handleNotificationIntent","getHelloMessage"],"sourceRoot":"../../src","sources":["BooleanMaths.native.tsx"],"mappings":";;AAAA,SAASA,QAAQ,QAAQ,cAAc;AACvC,OAAOC,uBAAuB,MAAM,8BAA2B;AAG/D;AACA;AACA;AACA;AACA;AACA,MAAMC,mBAAsD,GAAG,CAAC,SAAS,CAAC;AAE1E,MAAMC,mBAAmB,GAAGD,mBAAmB,CAACE,QAAQ,CAACJ,QAAQ,CAACK,EAAE,CAAC;;AAErE;AACA;AACA;AACA;AACA;AACA,MAAMC,WAAW,GAAGH,mBAAmB,IAAIF,uBAAuB,IAAI,IAAI;AAE1E,IAAIM,SAAS,GAAG,KAAK;AAErB,SAASC,QAAQA,CAAA,EAAG;EAClB,IAAID,SAAS,IAAI,CAACE,OAAO,EAAE;IACzB;EACF;EAEAF,SAAS,GAAG,IAAI;EAEhB,IAAI,CAACJ,mBAAmB,EAAE;IACxBO,OAAO,CAACC,IAAI,CACV,uFAAuFX,QAAQ,CAACK,EAAE,GAAG,GACnG,2EAA2E,GAC3E,2EAA2E,GAC3E,sEACJ,CAAC;IACD;EACF;EAEAK,OAAO,CAACC,IAAI,CACV,8EAA8E,GAC5E,GAAGX,QAAQ,CAACK,EAAE,0DAA0D,GACxE,yEAAyE,GACzE,6BACJ,CAAC;AACH;AAEA,OAAO,MAAMO,YAA6B,GAAG;EAC3CN,WAAW;EAEXO,UAAUA,CAACC,MAAc,EAAEC,OAAe,EAAQ;IAChD,IAAI,CAACT,WAAW,EAAE;MAChBE,QAAQ,CAAC,CAAC;MACV;IACF;IAEAP,uBAAuB,CAAEe,aAAa,CAACF,MAAM,EAAEC,OAAO,CAAC;EACzD,CAAC;EAEDE,UAAUA,CAACC,IAAY,EAAEC,UAAuC,GAAG,CAAC,CAAC,EAAQ;IAC3E,IAAI,CAACb,WAAW,EAAE;MAChBE,QAAQ,CAAC,CAAC;MACV;IACF;IAEAP,uBAAuB,CAAEgB,UAAU,CAACC,IAAI,EAAEC,UAAU,CAAC;EACvD,CAAC;EAEDC,wBAAwBA,CAAA,EAAS;IAC/B,IAAI,CAACd,WAAW,EAAE;MAChBE,QAAQ,CAAC,CAAC;MACV;IACF;IAEAP,uBAAuB,CAAEmB,wBAAwB,CAAC,CAAC;EACrD,CAAC;EAEDC,eAAeA,CAAA,EAAkB;IAC/B,IAAI,CAACf,WAAW,EAAE;MAChBE,QAAQ,CAAC,CAAC;MACV,OAAO,IAAI;IACb;IAEA,OAAOP,uBAAuB,CAAEoB,eAAe,CAAC,CAAC;EACnD;AACF,CAAC","ignoreList":[]}

package/lib/module/NativeBooleanmathsRnSdk.js

@@ -0,0 +1,9 @@
+"use strict";
+
+import { TurboModuleRegistry } from 'react-native';
+/**
+ * `get` rather than `getEnforcing` so that a missing/unlinked native module
+ * degrades to a warning instead of throwing at import time.
+ */
+export default TurboModuleRegistry.get('BooleanmathsRnSdk');
+//# sourceMappingURL=NativeBooleanmathsRnSdk.js.map

package/lib/module/NativeBooleanmathsRnSdk.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["TurboModuleRegistry","get"],"sourceRoot":"../../src","sources":["NativeBooleanmathsRnSdk.ts"],"mappings":";;AAAA,SAASA,mBAAmB,QAA0B,cAAc;AAiBpE;AACA;AACA;AACA;AACA,eAAeA,mBAAmB,CAACC,GAAG,CAAO,mBAAmB,CAAC","ignoreList":[]}

package/lib/module/index.js

@@ -0,0 +1,5 @@
+"use strict";
+
+export { BooleanMaths } from './BooleanMaths';
+export { BooleanMaths as default } from './BooleanMaths';
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["BooleanMaths","default"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA,SAASA,YAAY,QAAQ,gBAAgB;AAC7C,SAASA,YAAY,IAAIC,OAAO,QAAQ,gBAAgB","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/module/types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=types.js.map

package/lib/module/types.js.map

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

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/BooleanMaths.d.ts

@@ -0,0 +1,3 @@
+import type { BooleanMathsApi } from './types.js';
+export declare const BooleanMaths: BooleanMathsApi;
+//# sourceMappingURL=BooleanMaths.d.ts.map

package/lib/typescript/src/BooleanMaths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BooleanMaths.d.ts","sourceRoot":"","sources":["../../../src/BooleanMaths.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAA+B,MAAM,YAAS,CAAC;AAyB5E,eAAO,MAAM,YAAY,EAAE,eAmB1B,CAAC"}

package/lib/typescript/src/BooleanMaths.native.d.ts

@@ -0,0 +1,3 @@
+import type { BooleanMathsApi } from './types.js';
+export declare const BooleanMaths: BooleanMathsApi;
+//# sourceMappingURL=BooleanMaths.native.d.ts.map

package/lib/typescript/src/BooleanMaths.native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BooleanMaths.native.d.ts","sourceRoot":"","sources":["../../../src/BooleanMaths.native.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAA+B,MAAM,YAAS,CAAC;AA6C5E,eAAO,MAAM,YAAY,EAAE,eAsC1B,CAAC"}

package/lib/typescript/src/NativeBooleanmathsRnSdk.d.ts

@@ -0,0 +1,22 @@
+import { type TurboModule } from 'react-native';
+export interface Spec extends TurboModule {
+    /**
+     * Named `initializeSdk` rather than `initialize` on purpose: `initialize` is
+     * already taken by `NativeModule.initialize()` on Android and by
+     * `+[NSObject initialize]` on iOS. The public JS API exposes this as
+     * `BooleanMaths.initialize()`.
+     */
+    initializeSdk(apiKey: string, pixelId: string): void;
+    trackEvent(name: string, properties: Object): void;
+    /** Android only. No-op elsewhere. */
+    handleNotificationIntent(): void;
+    /** Smoke test that the native bridge is wired up. */
+    getHelloMessage(): string;
+}
+/**
+ * `get` rather than `getEnforcing` so that a missing/unlinked native module
+ * degrades to a warning instead of throwing at import time.
+ */
+declare const _default: Spec | null | undefined;
+export default _default;
+//# sourceMappingURL=NativeBooleanmathsRnSdk.d.ts.map

package/lib/typescript/src/NativeBooleanmathsRnSdk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeBooleanmathsRnSdk.d.ts","sourceRoot":"","sources":["../../../src/NativeBooleanmathsRnSdk.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAErE,MAAM,WAAW,IAAK,SAAQ,WAAW;IACvC;;;;;OAKG;IACH,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACrD,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnD,qCAAqC;IACrC,wBAAwB,IAAI,IAAI,CAAC;IACjC,qDAAqD;IACrD,eAAe,IAAI,MAAM,CAAC;CAC3B;AAED;;;GAGG;;AACH,wBAAkE"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,4 @@
+export { BooleanMaths } from './BooleanMaths';
+export { BooleanMaths as default } from './BooleanMaths';
+export type { BooleanMathsApi, BooleanMathsEventProperties, BooleanMathsPropertyValue, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,YAAY,IAAI,OAAO,EAAE,MAAM,gBAAgB,CAAC;AACzD,YAAY,EACV,eAAe,EACf,2BAA2B,EAC3B,yBAAyB,GAC1B,MAAM,YAAS,CAAC"}

package/lib/typescript/src/types.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Values allowed inside an event's `properties` payload.
+ *
+ * The payload is serialized to JSON natively, so only JSON-representable
+ * values survive the bridge. Nested objects and arrays are supported.
+ */
+export type BooleanMathsPropertyValue = string | number | boolean | null | undefined | BooleanMathsPropertyValue[] | {
+    [key: string]: BooleanMathsPropertyValue;
+};
+export type BooleanMathsEventProperties = Record<string, BooleanMathsPropertyValue>;
+export interface BooleanMathsApi {
+    /**
+     * Initializes the native SDK. Safe to call on any platform; on platforms
+     * without native support this is a no-op (see `isSupported`).
+     *
+     * Calling this more than once is harmless — the native SDK ignores
+     * subsequent calls.
+     */
+    initialize(apiKey: string, pixelId: string): void;
+    /**
+     * Records a custom event. Events are persisted locally and synced in the
+     * background, so this never blocks and never throws on network failure.
+     *
+     * No-op if `initialize` has not been called.
+     */
+    trackEvent(name: string, properties?: BooleanMathsEventProperties): void;
+    /**
+     * Forwards the current Activity's intent to the native SDK so deep-link and
+     * notification campaign data is attributed.
+     *
+     * Android only — a no-op on every other platform. Call this from your
+     * deep-link handler and once after `initialize`; see the README for why the
+     * launch intent needs this.
+     */
+    handleNotificationIntent(): void;
+    /**
+     * Returns the native SDK's hello message, or `null` when there is no native
+     * SDK on this platform. Useful as a bridge smoke test.
+     */
+    getHelloMessage(): string | null;
+    /**
+     * `true` only on platforms where a real BooleanMaths native SDK is linked.
+     * Currently Android only.
+     */
+    readonly isSupported: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,yBAAyB,GACjC,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,GACT,yBAAyB,EAAE,GAC3B;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,yBAAyB,CAAA;CAAE,CAAC;AAEjD,MAAM,MAAM,2BAA2B,GAAG,MAAM,CAC9C,MAAM,EACN,yBAAyB,CAC1B,CAAC;AAEF,MAAM,WAAW,eAAe;IAC9B;;;;;;OAMG;IACH,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAElD;;;;;OAKG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,2BAA2B,GAAG,IAAI,CAAC;IAEzE;;;;;;;OAOG;IACH,wBAAwB,IAAI,IAAI,CAAC;IAEjC;;;OAGG;IACH,eAAe,IAAI,MAAM,GAAG,IAAI,CAAC;IAEjC;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;CAC/B"}