react-native-carrot-quest 0.1.0

package/src/carrot-quest.native.tsx

@@ -0,0 +1,241 @@
+import { NitroModules } from 'react-native-nitro-modules';
+import type {
+  CarrotQuest,
+  CarrotQuestEventValue,
+  CarrotQuestLogEntry,
+  CarrotQuestProperty,
+  CarrotQuestSetupOptions,
+  CarrotQuestTheme,
+  CarrotQuestUrlSource,
+  CarrotQuestUserProperties,
+} from './CarrotQuest.nitro';
+import type { CarrotQuestSubscription } from './subscriptions';
+import { createChannel } from './subscriptions';
+
+const native = NitroModules.createHybridObject<CarrotQuest>('CarrotQuest');
+
+// MARK: - Lifecycle
+
+export function isConfigured(): boolean {
+  return native.isConfigured;
+}
+
+export function setup(
+  apiKey: string,
+  options?: CarrotQuestSetupOptions
+): Promise<void> {
+  return native.setup(apiKey, options);
+}
+
+export function getSdkVersion(): string {
+  return native.getSdkVersion();
+}
+
+// MARK: - Authentication
+
+export function auth(
+  userId: string,
+  userAuthKey: string
+): Promise<string | undefined> {
+  return native.auth(userId, userAuthKey);
+}
+
+export function hashedAuth(
+  userId: string,
+  hash: string
+): Promise<string | undefined> {
+  return native.hashedAuth(userId, hash);
+}
+
+export function logout(): Promise<void> {
+  return native.logout();
+}
+
+// MARK: - Chat UI
+
+export function openChat(): Promise<void> {
+  return native.openChat();
+}
+
+export function closeChat(): Promise<void> {
+  return native.closeChat();
+}
+
+export function isChatOpen(): boolean {
+  return native.isChatOpen;
+}
+
+const chatVisibilityChannel = createChannel<[boolean]>((dispatch) =>
+  native.onChatVisibilityChanged(dispatch)
+);
+
+export function onChatVisibilityChanged(
+  listener: (visible: boolean) => void
+): CarrotQuestSubscription {
+  return chatVisibilityChannel(listener);
+}
+
+export function setTheme(theme: CarrotQuestTheme): void {
+  native.setTheme(theme);
+}
+
+// MARK: - Unread state
+
+export function getUnreadConversationsCount(): Promise<number> {
+  return native.getUnreadConversationsCount();
+}
+
+export function getUnreadMessagesCount(): Promise<number | undefined> {
+  return native.getUnreadMessagesCount();
+}
+
+const unreadConversationsChannel = createChannel<[number]>((dispatch) =>
+  native.onUnreadConversationsChanged(dispatch)
+);
+
+export function onUnreadConversationsChanged(
+  listener: (count: number) => void
+): CarrotQuestSubscription {
+  return unreadConversationsChannel(listener);
+}
+
+// MARK: - User properties
+
+export function setUserProperties(properties: CarrotQuestUserProperties): void {
+  native.setUserProperties(properties);
+}
+
+export function setProperties(properties: CarrotQuestProperty[]): void {
+  native.setProperties(properties);
+}
+
+// MARK: - Tracking
+
+export function trackEvent(
+  name: string,
+  params?: Record<string, CarrotQuestEventValue>
+): void {
+  native.trackEvent(name, params);
+}
+
+export function trackScreen(name: string): void {
+  native.trackScreen(name);
+}
+
+export function trackUtm(url: string): void {
+  native.trackUtm(url);
+}
+
+// MARK: - Push notifications
+
+export function setPushToken(token: string): void {
+  native.setPushToken(token);
+}
+
+export function deletePushToken(): void {
+  native.deletePushToken();
+}
+
+export function pushNotificationsUnsubscribe(): Promise<void> {
+  return native.pushNotificationsUnsubscribe();
+}
+
+export function pushCampaignsUnsubscribe(): Promise<void> {
+  return native.pushCampaignsUnsubscribe();
+}
+
+/**
+ * Accepts either a decoded payload object or the raw JSON string the native
+ * side expects.
+ */
+const encodePayload = (payload: Record<string, unknown> | string): string =>
+  typeof payload === 'string' ? payload : JSON.stringify(payload);
+
+export function isCarrotPush(
+  payload: Record<string, unknown> | string
+): boolean {
+  return native.isCarrotPush(encodePayload(payload));
+}
+
+export function isAutoMessage(
+  payload: Record<string, unknown> | string
+): boolean {
+  return native.isAutoMessage(encodePayload(payload));
+}
+
+export function handlePushNotification(
+  payload: Record<string, unknown> | string
+): void {
+  native.handlePushNotification(encodePayload(payload));
+}
+
+export function handlePushClick(
+  payload: Record<string, unknown> | string,
+  openLink = true
+): void {
+  native.handlePushClick(encodePayload(payload), openLink);
+}
+
+export function getPushLink(
+  payload: Record<string, unknown> | string
+): string | undefined {
+  return native.getPushLink(encodePayload(payload));
+}
+
+export function wasPushShownEarlier(
+  payload: Record<string, unknown> | string
+): Promise<boolean> {
+  return native.wasPushShownEarlier(encodePayload(payload));
+}
+
+// MARK: - Deep links
+
+// The SDK registers a handler per url type, so each source gets its own
+// channel rather than sharing one.
+const urlChannels = new Map<
+  CarrotQuestUrlSource,
+  (listener: (url: string) => void) => CarrotQuestSubscription
+>();
+
+export function onUrlOpen(
+  source: CarrotQuestUrlSource,
+  listener: (url: string) => void
+): CarrotQuestSubscription {
+  let channel = urlChannels.get(source);
+
+  if (!channel) {
+    channel = createChannel<[string]>((dispatch) =>
+      native.onUrlOpen(source, dispatch)
+    );
+    urlChannels.set(source, channel);
+  }
+
+  return channel(listener);
+}
+
+export function openBrowserLink(url: string): void {
+  native.openBrowserLink(url);
+}
+
+export function openUniversalLink(url: string): void {
+  native.openUniversalLink(url);
+}
+
+// MARK: - Diagnostics
+
+export function getDiagnostics(): string | undefined {
+  return native.getDiagnostics();
+}
+
+// The only channel with a native detach — and the only one whose volume makes
+// it matter, since a verbose log level pushes an entry per network call.
+const logChannel = createChannel<[CarrotQuestLogEntry]>(
+  (dispatch) => native.onLog(dispatch),
+  () => native.offLog()
+);
+
+export function onLog(
+  listener: (entry: CarrotQuestLogEntry) => void
+): CarrotQuestSubscription {
+  return logChannel(listener);
+}

package/src/carrot-quest.tsx

@@ -0,0 +1,207 @@
+import type {
+  CarrotQuestEventValue,
+  CarrotQuestLogEntry,
+  CarrotQuestProperty,
+  CarrotQuestSetupOptions,
+  CarrotQuestTheme,
+  CarrotQuestUrlSource,
+  CarrotQuestUserProperties,
+} from './CarrotQuest.nitro';
+import type { CarrotQuestSubscription } from './subscriptions';
+import { noopSubscription } from './subscriptions';
+
+const unsupported = (method: string): never => {
+  throw new Error(
+    `react-native-carrot-quest: ${method}() is only supported on iOS and Android.`
+  );
+};
+
+// MARK: - Lifecycle
+
+export function isConfigured(): boolean {
+  return false;
+}
+
+export function setup(
+  _apiKey: string,
+  _options?: CarrotQuestSetupOptions
+): Promise<void> {
+  return unsupported('setup');
+}
+
+export function getSdkVersion(): string {
+  return unsupported('getSdkVersion');
+}
+
+// MARK: - Authentication
+
+export function auth(
+  _userId: string,
+  _userAuthKey: string
+): Promise<string | undefined> {
+  return unsupported('auth');
+}
+
+export function hashedAuth(
+  _userId: string,
+  _hash: string
+): Promise<string | undefined> {
+  return unsupported('hashedAuth');
+}
+
+export function logout(): Promise<void> {
+  return unsupported('logout');
+}
+
+// MARK: - Chat UI
+
+export function openChat(): Promise<void> {
+  return unsupported('openChat');
+}
+
+export function closeChat(): Promise<void> {
+  return unsupported('closeChat');
+}
+
+export function isChatOpen(): boolean {
+  return false;
+}
+
+export function onChatVisibilityChanged(
+  _listener: (visible: boolean) => void
+): CarrotQuestSubscription {
+  return noopSubscription;
+}
+
+export function setTheme(_theme: CarrotQuestTheme): void {
+  unsupported('setTheme');
+}
+
+// MARK: - Unread state
+
+export function getUnreadConversationsCount(): Promise<number> {
+  return unsupported('getUnreadConversationsCount');
+}
+
+export function getUnreadMessagesCount(): Promise<number | undefined> {
+  return unsupported('getUnreadMessagesCount');
+}
+
+export function onUnreadConversationsChanged(
+  _listener: (count: number) => void
+): CarrotQuestSubscription {
+  return noopSubscription;
+}
+
+// MARK: - User properties
+
+export function setUserProperties(
+  _properties: CarrotQuestUserProperties
+): void {
+  unsupported('setUserProperties');
+}
+
+export function setProperties(_properties: CarrotQuestProperty[]): void {
+  unsupported('setProperties');
+}
+
+// MARK: - Tracking
+
+export function trackEvent(
+  _name: string,
+  _params?: Record<string, CarrotQuestEventValue>
+): void {
+  unsupported('trackEvent');
+}
+
+export function trackScreen(_name: string): void {
+  unsupported('trackScreen');
+}
+
+export function trackUtm(_url: string): void {
+  unsupported('trackUtm');
+}
+
+// MARK: - Push notifications
+
+export function setPushToken(_token: string): void {
+  unsupported('setPushToken');
+}
+
+export function deletePushToken(): void {
+  unsupported('deletePushToken');
+}
+
+export function pushNotificationsUnsubscribe(): Promise<void> {
+  return unsupported('pushNotificationsUnsubscribe');
+}
+
+export function pushCampaignsUnsubscribe(): Promise<void> {
+  return unsupported('pushCampaignsUnsubscribe');
+}
+
+export function isCarrotPush(
+  _payload: Record<string, unknown> | string
+): boolean {
+  return false;
+}
+
+export function isAutoMessage(
+  _payload: Record<string, unknown> | string
+): boolean {
+  return false;
+}
+
+export function handlePushNotification(
+  _payload: Record<string, unknown> | string
+): void {
+  unsupported('handlePushNotification');
+}
+
+export function handlePushClick(
+  _payload: Record<string, unknown> | string,
+  _openLink?: boolean
+): void {
+  unsupported('handlePushClick');
+}
+
+export function getPushLink(
+  _payload: Record<string, unknown> | string
+): string | undefined {
+  return undefined;
+}
+
+export function wasPushShownEarlier(
+  _payload: Record<string, unknown> | string
+): Promise<boolean> {
+  return Promise.resolve(false);
+}
+
+// MARK: - Deep links
+
+export function onUrlOpen(
+  _source: CarrotQuestUrlSource,
+  _listener: (url: string) => void
+): CarrotQuestSubscription {
+  return noopSubscription;
+}
+
+export function openBrowserLink(_url: string): void {
+  unsupported('openBrowserLink');
+}
+
+export function openUniversalLink(_url: string): void {
+  unsupported('openUniversalLink');
+}
+
+// MARK: - Diagnostics
+
+export function getDiagnostics(): string | undefined {
+  return undefined;
+}
+
+export function onLog(
+  _listener: (entry: CarrotQuestLogEntry) => void
+): CarrotQuestSubscription {
+  return noopSubscription;
+}

package/src/index.tsx

@@ -0,0 +1,57 @@
+import * as CarrotQuest from './carrot-quest';
+
+export default CarrotQuest;
+
+export {
+  auth,
+  closeChat,
+  deletePushToken,
+  getDiagnostics,
+  getPushLink,
+  getSdkVersion,
+  getUnreadConversationsCount,
+  getUnreadMessagesCount,
+  handlePushClick,
+  handlePushNotification,
+  hashedAuth,
+  isAutoMessage,
+  isCarrotPush,
+  isChatOpen,
+  isConfigured,
+  logout,
+  onChatVisibilityChanged,
+  onLog,
+  onUnreadConversationsChanged,
+  onUrlOpen,
+  openBrowserLink,
+  openChat,
+  openUniversalLink,
+  pushCampaignsUnsubscribe,
+  pushNotificationsUnsubscribe,
+  setProperties,
+  setPushToken,
+  setTheme,
+  setUserProperties,
+  setup,
+  trackEvent,
+  trackScreen,
+  trackUtm,
+} from './carrot-quest';
+
+export type { CarrotQuestSubscription } from './subscriptions';
+
+export type {
+  CarrotQuest,
+  CarrotQuestEcommerceProperty,
+  CarrotQuestEventValue,
+  CarrotQuestLogCategory,
+  CarrotQuestLogEntry,
+  CarrotQuestLogLevel,
+  CarrotQuestProperty,
+  CarrotQuestPropertyKind,
+  CarrotQuestPropertyOperation,
+  CarrotQuestSetupOptions,
+  CarrotQuestTheme,
+  CarrotQuestUrlSource,
+  CarrotQuestUserProperties,
+} from './CarrotQuest.nitro';

package/src/subscriptions.ts

@@ -0,0 +1,83 @@
+/**
+ * A JS-side listener registry that multiplexes many subscribers over a single
+ * native callback.
+ *
+ * Each SDK hook (`onVisibilityUIChanged`, `setCloseChatCallback`,
+ * `setUnreadConversationsCallback`, `CustomUrlOpener.set(for:)`) is a *setter*:
+ * registering twice replaces the first callback. Handing that directly to app
+ * code means two components cannot both listen, and a component that remounts
+ * — or is hot-reloaded — leaves a stale closure installed with no way to
+ * detach it.
+ *
+ * So the native callback is installed exactly once per channel, and fan-out
+ * happens here where a subscription can actually be removed.
+ */
+
+/** Returned by every listener registration. Call `remove()` to unsubscribe. */
+export interface CarrotQuestSubscription {
+  remove(): void;
+}
+
+const noopSubscription: CarrotQuestSubscription = { remove: () => {} };
+
+export { noopSubscription };
+
+/**
+ * Creates an `add(listener)` function for one native channel.
+ *
+ * @param install receives the fan-out dispatcher and wires it to the native
+ *   callback. Called on the first subscription, and again after a teardown.
+ * @param uninstall detaches the native callback once the last listener is
+ *   removed. Omit it for channels the SDK cannot detach — the dispatcher then
+ *   stays installed and fans out to an empty set, which is only acceptable for
+ *   low-frequency signals.
+ */
+export function createChannel<Args extends unknown[]>(
+  install: (dispatch: (...args: Args) => void) => void,
+  uninstall?: () => void
+): (listener: (...args: Args) => void) => CarrotQuestSubscription {
+  const listeners = new Set<(...args: Args) => void>();
+  let installed = false;
+
+  const dispatch = (...args: Args) => {
+    // Copy first: a listener may unsubscribe itself (or another) while we emit.
+    for (const listener of [...listeners]) {
+      try {
+        listener(...args);
+      } catch (error) {
+        // One misbehaving subscriber must not stop the others, and this call
+        // originates from native code where a throw has nowhere to go.
+        console.error('react-native-carrot-quest: listener threw', error);
+      }
+    }
+  };
+
+  return (listener) => {
+    if (!installed) {
+      // Install lazily so merely importing the package does not register
+      // native callbacks.
+      installed = true;
+      install(dispatch);
+    }
+
+    listeners.add(listener);
+
+    let removed = false;
+
+    return {
+      remove: () => {
+        // Idempotent: removing twice must not disturb a re-added listener.
+        if (removed) return;
+        removed = true;
+        listeners.delete(listener);
+
+        // Detach once nobody is listening, so native stops pushing across the
+        // bridge. The next subscription reinstalls.
+        if (listeners.size === 0 && uninstall && installed) {
+          installed = false;
+          uninstall();
+        }
+      },
+    };
+  };
+}