@bubblsdk/react-native-sdk 4.1.7 → 5.0.0-alpha.1

package/ios/BubblSdk.mm

@@ -0,0 +1,252 @@
+#import "BubblSdk.h"
+
+// Before the Swift header: BubblPush's signatures use UserNotifications types.
+#import <UserNotifications/UserNotifications.h>
+
+#if __has_include(<BubblReactNativeSdk/BubblReactNativeSdk-Swift.h>)
+#import <BubblReactNativeSdk/BubblReactNativeSdk-Swift.h>
+#else
+#import "BubblReactNativeSdk-Swift.h"
+#endif
+
+static NSString *const BubblSdkEvent = @"BubblSdkEvent";
+
+@implementation BubblSdk {
+  BubblSdkImpl *_impl;
+  BOOL _hasListeners;
+}
+
+RCT_EXPORT_MODULE(BubblSdk)
+
+- (instancetype)init
+{
+  if (self = [super init]) {
+    __weak BubblSdk *weakSelf = self;
+    _impl = [[BubblSdkImpl alloc] initWithEmit:^BOOL(NSString *json) {
+      return [weakSelf emit:json];
+    }];
+  }
+  return self;
+}
+
++ (BOOL)requiresMainQueueSetup
+{
+  return NO;
+}
+
+- (NSArray<NSString *> *)supportedEvents
+{
+  return @[ BubblSdkEvent ];
+}
+
+- (void)startObserving
+{
+  _hasListeners = YES;
+}
+
+- (void)stopObserving
+{
+  _hasListeners = NO;
+}
+
+/// Whether JS got it: with no JS listener it can't (a notification then stays Bubbl's to show).
+- (BOOL)emit:(NSString *)json
+{
+  if (!_hasListeners) {
+    return NO;
+  }
+  [self sendEventWithName:BubblSdkEvent body:json];
+  return YES;
+}
+
+- (void)invalidate
+{
+  [_impl invalidate];
+  [super invalidate];
+}
+
+// MARK: - Starting, consent and privacy
+
+- (NSNumber *)isSupported
+{
+  return @([_impl isSupported]);
+}
+
+- (void)start:(NSString *)apiKey optionsJson:(NSString *)optionsJson
+{
+  [_impl startWithApiKey:apiKey optionsJson:optionsJson];
+}
+
+- (void)startWithCredential:(NSString *)keyId
+                     secret:(NSString *)secret
+                  installId:(NSString *)installId
+                optionsJson:(NSString *)optionsJson
+{
+  [_impl startWithCredentialWithKeyId:keyId secret:secret installId:installId optionsJson:optionsJson];
+}
+
+- (void)stop
+{
+  [_impl stop];
+}
+
+- (void)setConsent:(BOOL)granted
+{
+  [_impl setConsent:granted];
+}
+
+- (void)optOut
+{
+  [_impl optOut];
+}
+
+- (void)deleteMyData
+{
+  [_impl deleteMyData];
+}
+
+- (void)setLocationEnabled:(BOOL)enabled
+{
+  [_impl setLocationEnabled:enabled];
+}
+
+// MARK: - Permissions (JSON, or null before start)
+
+- (void)permissionStatus:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  resolve([_impl permissionStatus]);
+}
+
+- (void)requestNotifications:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  [_impl requestNotifications:^(NSString *json) {
+    resolve(json);
+  }];
+}
+
+- (void)requestLocation:(BOOL)always resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  [_impl requestLocationWithAlways:always completion:^(NSString *json) {
+    resolve(json);
+  }];
+}
+
+- (void)openSettings
+{
+  [_impl openSettings];
+}
+
+// MARK: - Targeting and events
+
+- (void)setSegments:(NSArray *)segments
+{
+  NSMutableArray<NSString *> *names = [NSMutableArray array];
+  for (id segment in segments) {
+    if ([segment isKindOfClass:[NSString class]] && [segment length] > 0) {
+      [names addObject:segment];
+    }
+  }
+  [_impl setSegments:names];
+}
+
+- (void)track:(NSString *)name propertiesJson:(NSString *)propertiesJson
+{
+  [_impl trackWithName:name propertiesJson:propertiesJson];
+}
+
+// MARK: - Notifications
+
+- (void)setNotificationListenerEnabled:(BOOL)enabled
+{
+  [_impl setNotificationListenerEnabled:enabled];
+}
+
+- (void)claimNotification:(NSString *)token
+{
+  [_impl claimNotification:token];
+}
+
+- (void)finishNotification:(NSString *)token appShowsIt:(BOOL)appShowsIt
+{
+  [_impl finishNotification:token appShowsIt:appShowsIt];
+}
+
+- (void)present:(NSString *)messageJson
+{
+  [_impl present:messageJson];
+}
+
+- (void)reportDisplayed:(NSString *)messageJson
+{
+  [_impl reportDisplayed:messageJson];
+}
+
+- (void)reportOpened:(NSString *)messageJson
+{
+  [_impl reportOpened:messageJson];
+}
+
+- (void)reportCtaClicked:(NSString *)messageJson
+{
+  [_impl reportCtaClicked:messageJson];
+}
+
+- (void)reportDismissed:(NSString *)messageJson
+{
+  [_impl reportDismissed:messageJson];
+}
+
+- (void)reportMediaViewed:(NSString *)messageJson
+{
+  [_impl reportMediaViewed:messageJson];
+}
+
+- (void)reportMediaCompleted:(NSString *)messageJson durationSeconds:(double)durationSeconds
+{
+  [_impl reportMediaCompleted:messageJson durationSeconds:durationSeconds];
+}
+
+- (void)reportSurveyStarted:(NSString *)messageJson
+{
+  [_impl reportSurveyStarted:messageJson];
+}
+
+- (void)submitSurvey:(NSString *)messageJson
+         answersJson:(NSString *)answersJson
+             resolve:(RCTPromiseResolveBlock)resolve
+              reject:(RCTPromiseRejectBlock)reject
+{
+  resolve(@([_impl submitSurvey:messageJson answersJson:answersJson]));
+}
+
+- (void)openCta:(NSString *)messageJson
+{
+  [_impl openCta:messageJson];
+}
+
+// MARK: - Sandbox
+
+- (void)registerTestDevice:(NSString *)code resolve:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  [_impl registerTestDevice:code completion:^(NSString *json) {
+    resolve(json);
+  }];
+}
+
+// MARK: - Diagnostics
+
+- (void)diagnostics:(RCTPromiseResolveBlock)resolve reject:(RCTPromiseRejectBlock)reject
+{
+  [_impl diagnostics:^(NSString *json) {
+    resolve(json);
+  }];
+}
+
+// MARK: - TurboModule
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:(const facebook::react::ObjCTurboModule::InitParams &)params
+{
+  return std::make_shared<facebook::react::NativeBubblSdkSpecJSI>(params);
+}
+
+@end

package/ios/BubblSdkImpl.swift

@@ -0,0 +1,335 @@
+import Foundation
+import UIKit
+
+/// The Swift side of the React Native module (BubblSdk.mm calls it): each function passes straight
+/// to the iOS SDK (`Bubbl`, built into this pod), with JSON across the bridge in the same shapes as
+/// the Android module and the Flutter wrapper:
+///  - a message goes to JS as the public BubblMessage fields plus its contract JSON, and comes back
+///    as that JSON alone (`BubblMessage(json:)`);
+///  - events go as {"type": "notification.received", ...}, the SDK's own event names;
+///  - options, properties, answers and diagnostics are JSON objects.
+///
+/// The notification listener: while JS has one and the app is active, this takes the notification
+/// over and hands it to JS ("notification.handle"), which shows it itself or calls present().
+/// Otherwise Bubbl shows it as usual.
+@objc(BubblSdkImpl)
+public final class BubblSdkImpl: NSObject {
+    /// Sends JSON to JS on the module's one event (BubblSdkEvent); false when JS isn't listening.
+    private let emit: (String) -> Bool
+    private var eventToken: BubblEventToken?
+
+    /// How long JS has to claim a notification handed to it before Bubbl shows it.
+    static let claimTimeout: TimeInterval = 5
+
+    /// The instance whose JS set the app's notification listener (main thread only).
+    private static weak var owner: BubblSdkImpl?
+
+    /// Notifications handed to JS and not yet settled, by token (main thread only): JS claims one
+    /// when it arrives and finishes it once the app's listener has decided.
+    private var handedOver: [String: (message: BubblMessage, timeout: DispatchWorkItem)] = [:]
+    private var nextToken = 0
+
+    @objc public init(emit: @escaping (String) -> Bool) {
+        self.emit = emit
+        super.init()
+        eventToken = Bubbl.addEventListener { [weak self] event in
+            guard let self, let json = Self.event(event).flatMap(Self.json) else { return }
+            _ = self.emit(json)
+        }
+    }
+
+    /// The module is going away (a JS reload): stop listening, and show whatever JS was handed and
+    /// hadn't settled. The app's listener is cleared only if this instance set it.
+    @objc public func invalidate() {
+        if let eventToken { Bubbl.removeEventListener(eventToken) }
+        eventToken = nil
+        DispatchQueue.main.async { [self] in
+            for handover in handedOver.values {
+                handover.timeout.cancel()
+                Bubbl.present(handover.message)
+            }
+            handedOver.removeAll()
+            if Self.owner === self {
+                Self.owner = nil
+                Bubbl.setNotificationListener(nil)
+            }
+        }
+    }
+
+    // MARK: - Starting, consent and privacy
+
+    /// Bubbl works on this device (iOS 17 and later); below, every call does nothing.
+    @objc public var isSupported: Bool { Bubbl.isSupported }
+
+    /// A mistake (an empty key, an http:// URL) is logged by the SDK, never thrown.
+    @objc public func start(apiKey: String, optionsJson: String) {
+        Bubbl.start(apiKey: apiKey, options: Self.options(Self.object(optionsJson)))
+    }
+
+    /// The secret goes to the SDK and nowhere else: it arrives as its own argument (never inside
+    /// JSON), and the SDK logs an incomplete credential without it (BubblCredential's description
+    /// hides it).
+    @objc public func startWithCredential(keyId: String, secret: String, installId: String, optionsJson: String) {
+        Bubbl.start(
+            credential: BubblCredential(keyId: keyId, secret: secret, installId: installId),
+            options: Self.options(Self.object(optionsJson))
+        )
+    }
+
+    @objc public func stop() { Bubbl.stop() }
+    @objc public func setConsent(_ granted: Bool) { Bubbl.setConsent(granted) }
+    @objc public func optOut() { Bubbl.optOut() }
+    @objc public func deleteMyData() { Bubbl.deleteMyData() }
+    @objc public func setLocationEnabled(_ enabled: Bool) { Bubbl.setLocationEnabled(enabled) }
+
+    // MARK: - Targeting and events
+
+    @objc public func setSegments(_ segments: [String]) { Bubbl.setSegments(segments) }
+
+    @objc public func track(name: String, propertiesJson: String) {
+        Bubbl.track(name, properties: Self.plain(Self.object(propertiesJson)))
+    }
+
+    // MARK: - Notifications
+
+    @objc public func setNotificationListenerEnabled(_ enabled: Bool) {
+        DispatchQueue.main.async { [self] in
+            guard enabled else {
+                if Self.owner === self {
+                    Self.owner = nil
+                    Bubbl.setNotificationListener(nil)
+                }
+                return
+            }
+            Self.owner = self
+            Bubbl.setNotificationListener { @MainActor [weak self] (message: BubblMessage) -> Bool in
+                self?.handOver(message) ?? false
+            }
+        }
+    }
+
+    /// JS has the notification: the timeout that would show it is off.
+    @objc public func claimNotification(_ token: String) {
+        DispatchQueue.main.async { [self] in handedOver[token]?.timeout.cancel() }
+    }
+
+    /// The app's listener decided: Bubbl shows the notification unless the app does.
+    @objc public func finishNotification(_ token: String, appShowsIt: Bool) {
+        DispatchQueue.main.async { [self] in
+            guard let handover = handedOver.removeValue(forKey: token) else { return }
+            handover.timeout.cancel()
+            if !appShowsIt { Bubbl.present(handover.message) }
+        }
+    }
+
+    @objc public func present(_ json: String) { withMessage(json, "present") { Bubbl.present($0) } }
+    @objc public func reportDisplayed(_ json: String) { withMessage(json, "reportDisplayed") { Bubbl.reportDisplayed($0) } }
+    @objc public func reportOpened(_ json: String) { withMessage(json, "reportOpened") { Bubbl.reportOpened($0) } }
+    @objc public func reportCtaClicked(_ json: String) { withMessage(json, "reportCtaClicked") { Bubbl.reportCtaClicked($0) } }
+    @objc public func reportDismissed(_ json: String) { withMessage(json, "reportDismissed") { Bubbl.reportDismissed($0) } }
+    @objc public func reportMediaViewed(_ json: String) { withMessage(json, "reportMediaViewed") { Bubbl.reportMediaViewed($0) } }
+    @objc public func reportSurveyStarted(_ json: String) { withMessage(json, "reportSurveyStarted") { Bubbl.reportSurveyStarted($0) } }
+    @objc public func openCta(_ json: String) { withMessage(json, "openCta") { Bubbl.openCta($0) } }
+
+    @objc public func reportMediaCompleted(_ json: String, durationSeconds: Double) {
+        withMessage(json, "reportMediaCompleted") { Bubbl.reportMediaCompleted($0, durationSeconds: durationSeconds) }
+    }
+
+    @objc public func submitSurvey(_ json: String, answersJson: String) -> Bool {
+        guard let message = BubblMessage(json: json) else {
+            NSLog("[Bubbl] Bubbl.submitSurvey: that isn't a Bubbl message's json")
+            return false
+        }
+        return Bubbl.submitSurvey(message, answers: Self.plain(Self.object(answersJson)))
+    }
+
+    // MARK: - Permissions
+
+    /// Where the device stands, as JSON; nil before start.
+    @objc public func permissionStatus() -> String? {
+        Bubbl.permissions.status().flatMap { Self.json(Self.permissions($0)) }
+    }
+
+    /// The privacy view if the dashboard says so, then the system prompt; the status after, on the
+    /// main thread (nil before start).
+    @objc public func requestNotifications(_ completion: @escaping (String?) -> Void) {
+        Bubbl.permissions.requestNotifications { status in
+            completion(status.flatMap { Self.json(Self.permissions($0)) })
+        }
+    }
+
+    /// The same for location; with `always`, the second step to "Always" too.
+    @objc public func requestLocation(always: Bool, completion: @escaping (String?) -> Void) {
+        Bubbl.permissions.requestLocation(always: always) { status in
+            completion(status.flatMap { Self.json(Self.permissions($0)) })
+        }
+    }
+
+    @objc public func openSettings() { Bubbl.permissions.openSettings() }
+
+    // MARK: - Sandbox
+
+    /// Approve this device as a Sandbox test device with the dashboard's code: {approved, message}
+    /// as JSON, on the main thread.
+    @objc public func registerTestDevice(_ code: String, completion: @escaping (String) -> Void) {
+        Bubbl.registerTestDevice(code) { result in
+            completion(Self.json(["approved": result.approved, "message": result.message ?? NSNull()]) ?? "{\"approved\":false}")
+        }
+    }
+
+    // MARK: - Diagnostics
+
+    /// Bubbl.Diagnostics as JSON, on the main thread.
+    @objc public func diagnostics(_ completion: @escaping (String) -> Void) {
+        Bubbl.diagnostics { diagnostics in completion(Self.json(Self.diagnostics(diagnostics)) ?? "{}") }
+    }
+
+    // MARK: -
+
+    private func withMessage(_ json: String, _ call: String, _ action: (BubblMessage) -> Void) {
+        guard let message = BubblMessage(json: json) else {
+            NSLog("[Bubbl] Bubbl.%@: that isn't a Bubbl message's json", call)
+            return
+        }
+        action(message)
+    }
+
+    /// The SDK asks, on the main thread, whether the app shows `message` itself: yes while the app
+    /// is active and JS is listening, and JS decides; no otherwise. Handed over, it's JS's to settle;
+    /// if JS doesn't claim it in time (reloading, stuck), Bubbl shows it: it's never lost.
+    @MainActor
+    private func handOver(_ message: BubblMessage) -> Bool {
+        nextToken += 1
+        let token = String(nextToken)
+        guard UIApplication.shared.applicationState == .active,
+              let json = Self.json(["type": "notification.handle", "token": token, "message": Self.message(message)])
+        else { return false }
+        let timeout = DispatchWorkItem { [weak self] in
+            if let handover = self?.handedOver.removeValue(forKey: token) { Bubbl.present(handover.message) }
+        }
+        handedOver[token] = (message, timeout)
+        guard emit(json) else {
+            handedOver[token] = nil
+            return false
+        }
+        DispatchQueue.main.asyncAfter(deadline: .now() + Self.claimTimeout, execute: timeout)
+        return true
+    }
+
+    // MARK: - JSON (the same shapes as android/…/BubblJson.kt)
+
+    static func object(_ text: String) -> [String: Any] {
+        guard let data = text.data(using: .utf8),
+              let object = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+        else { return [:] }
+        return object
+    }
+
+    /// JSON nulls as nil, for the SDK's `[String: Any?]` parameters.
+    static func plain(_ object: [String: Any]) -> [String: Any?] {
+        object.mapValues { value -> Any? in value is NSNull ? nil : value }
+    }
+
+    static func json(_ object: [String: Any]) -> String? {
+        guard let data = try? JSONSerialization.data(withJSONObject: object) else { return nil }
+        return String(data: data, encoding: .utf8)
+    }
+
+    static func options(_ json: [String: Any]) -> BubblOptions {
+        let name = json["logLevel"] as? String
+        return BubblOptions(
+            baseUrl: json["baseUrl"] as? String ?? "",
+            requireConsent: json["requireConsent"] as? Bool ?? false,
+            logLevel: BubblOptions.LogLevel.allCases.first { "\($0)" == name } ?? .warning,
+            segments: json["segments"] as? [String]
+        )
+    }
+
+    /// The public BubblMessage for JS: its fields as the SDK works them out, and its JSON.
+    static func message(_ message: BubblMessage) -> [String: Any] {
+        [
+            "id": message.id,
+            "headline": message.headline,
+            "body": message.body,
+            "isSurvey": message.isSurvey,
+            "isSandbox": message.isSandbox,
+            "mediaType": message.mediaType ?? NSNull(),
+            "mediaUrl": message.mediaUrl ?? NSNull(),
+            "mediaThumbnailUrl": message.mediaThumbnailUrl ?? NSNull(),
+            "ctaLabel": message.ctaLabel ?? NSNull(),
+            "ctaUrl": message.ctaUrl ?? NSNull(),
+            "questions": message.questions.map { question -> [String: Any] in
+                [
+                    "id": question.id,
+                    "text": question.text,
+                    // The case name (openEnded, singleChoice…), as the TS type names them.
+                    "type": "\(question.type)",
+                    "required": question.required,
+                    "choices": question.choices.map { ["id": $0.id, "text": $0.text] },
+                ]
+            },
+            "json": message.json,
+        ]
+    }
+
+    static func event(_ event: BubblEvent) -> [String: Any]? {
+        func with(_ type: String, _ message: BubblMessage) -> [String: Any] { ["type": type, "message": Self.message(message)] }
+        switch event {
+        case .notificationReceived(let message): return with("notification.received", message)
+        case .notificationDisplayed(let message): return with("notification.displayed", message)
+        case .notificationOpened(let message): return with("notification.opened", message)
+        case .notificationCtaClicked(let message): return with("notification.cta_clicked", message)
+        case .notificationDismissed(let message): return with("notification.dismissed", message)
+        case .mediaViewed(let message): return with("media.viewed", message)
+        case .mediaCompleted(let message): return with("media.completed", message)
+        case .surveyStarted(let message): return with("survey.started", message)
+        case .surveySubmitted(let message): return with("survey.submitted", message)
+        case .geofenceEntered(let locationId): return ["type": "geofence.entered", "locationId": locationId]
+        case .geofenceExited(let locationId): return ["type": "geofence.exited", "locationId": locationId]
+        case .error(let message): return ["type": "error", "message": message]
+        case .credentialRejected: return ["type": "credential.rejected"]
+        }
+    }
+
+    /// {notifications, location, preciseLocation}, with the case names (notDetermined, whenInUse…)
+    /// the TS type and the Android module use.
+    static func permissions(_ status: BubblPermissionStatus) -> [String: Any] {
+        [
+            "notifications": "\(status.notifications)",
+            "location": "\(status.location)",
+            "preciseLocation": status.preciseLocation,
+        ]
+    }
+
+    /// The same fields as the Android module sends; Android's own extras are null here.
+    static func diagnostics(_ diagnostics: Bubbl.Diagnostics) -> [String: Any] {
+        [
+            "started": diagnostics.started,
+            "sdkVersion": diagnostics.sdkVersion,
+            "supported": diagnostics.supported,
+            "sdkSupported": diagnostics.sdkSupported,
+            "registered": diagnostics.registered,
+            "installId": diagnostics.installId ?? NSNull(),
+            "active": diagnostics.active,
+            "pausedUntil": diagnostics.pausedUntil.map { NSNumber(value: $0) } ?? NSNull(),
+            "consentRequired": diagnostics.consentRequired,
+            "consent": diagnostics.consent.map { NSNumber(value: $0) } ?? NSNull(),
+            "locationEnabled": diagnostics.locationEnabled,
+            "permissions": diagnostics.permissions.map(Self.permissions) ?? NSNull(),
+            "hasPushToken": diagnostics.hasPushToken,
+            "geofences": diagnostics.geofences,
+            "queuedEvents": diagnostics.queuedEvents,
+            "lastError": diagnostics.lastError ?? NSNull(),
+            "credentialRejected": diagnostics.credentialRejected,
+            "environment": diagnostics.environment ?? NSNull(),
+            "testDevice": diagnostics.testDevice.map { ["status": $0.status, "code": $0.code ?? NSNull()] as [String: Any] } ?? NSNull(),
+            "backgroundLocation": diagnostics.backgroundLocation,
+            "transitionsDroppedWhileLocked": diagnostics.transitionsDroppedWhileLocked,
+            "backgroundRestricted": NSNull(),
+            "batteryOptimized": NSNull(),
+            "backgroundRefreshAvailable": diagnostics.backgroundRefreshAvailable,
+            "lowPowerMode": diagnostics.lowPowerMode,
+            "osWatchesGeofences": diagnostics.osWatchesGeofences,
+        ]
+    }
+}

package/ios-extension/BubblReactNativeNotificationService.podspec

@@ -0,0 +1,44 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+# Bubbl's pictures on pushes, for the app's Notification Service Extension target (optional): the
+# iOS SDK's BubblNotificationService and the plain-Swift core it reads pushes with, copied into
+# Sources/ by scripts/sync-ios-sources.mjs. No React Native in it: an extension is its own small
+# process. In the Podfile, for the extension's target:
+#
+#     target 'NotificationService' do
+#       pod 'BubblReactNativeNotificationService', :path => '../node_modules/@bubblsdk/react-native-sdk/ios-extension'
+#     end
+#
+# and the extension's principal class:
+#
+#     import BubblNotificationService
+#     class NotificationService: BubblNotificationService {}
+#
+# Its own folder (not the package root), so React Native's autolinking never adds it to the app.
+Pod::Spec.new do |s|
+  s.name = 'BubblReactNativeNotificationService'
+  # Imported as the iOS SDK's own product is: `import BubblNotificationService`.
+  s.module_name = 'BubblNotificationService'
+  s.version = package['version']
+  s.summary = "Pictures on Bubbl's pushes, for a React Native app's Notification Service Extension."
+  s.homepage = 'https://bubbl.tech'
+  s.license = { :type => 'Apache-2.0' }
+  s.author = { 'Bubbl' => 'engineering@bubbl.tech' }
+  s.source = { :git => 'https://github.com/bubbl-platform/renewed-sdk.git', :tag => "v#{s.version}" }
+
+  # The service shows pictures on iOS 17 and up and passes pushes through untouched below.
+  s.platforms = { :ios => defined?(min_ios_version_supported) ? min_ios_version_supported : '13.0' }
+  s.swift_version = '5.9'
+  s.source_files = 'Sources/**/*.swift'
+  s.frameworks = 'UserNotifications'
+  # iOS 14 and up (used only on 17 and up): weak, so an older iOS still loads the extension.
+  s.weak_frameworks = 'UniformTypeIdentifiers'
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+    'APPLICATION_EXTENSION_API_ONLY' => 'YES',
+    # The core's `package` declarations, built here into one module with the service.
+    'OTHER_SWIFT_FLAGS' => '$(inherited) -package-name BubblReactNativeNotificationService',
+  }
+end