@repzo/widget-react-native 1.1.0 → 1.2.1

package/src/api/client.ts

@@ -16,8 +16,11 @@ import type {
   InitResponse,
   Message,
   OutboundMessage,
+  PostInteractionKind,
+  PostReply,
   RepzoWidgetErrorCode,
   WidgetConfig,
+  WidgetPost,
   WidgetUser,
 } from '../types';
 import { isHttpUrl, urlScheme } from '../ui/utils/safe-url';
@@ -194,6 +197,30 @@ export class WidgetApiClient {
     return this.request(`/api/widget/outbound/${encodeURIComponent(this.channelAccountId)}`);
   }
 
+  /**
+   * The Send post this visitor should see now, if any.
+   * `recheckInMs`: ask again after this long — the shown one stops then.
+   */
+  getPost(): Promise<{ post: WidgetPost | null; recheckInMs?: number | null }> {
+    return this.request('/api/widget/send/post?platform=mobile');
+  }
+
+  /**
+   * Reports what the visitor did with a post; `hidden` means load the next
+   * one. A reply comes back as saved (`reply`) — it's also delivered to the
+   * post's conversation in the inbox, where the team answers.
+   */
+  sendPostInteraction(
+    campaignId: string,
+    kind: PostInteractionKind,
+    value?: string
+  ): Promise<{ hidden: boolean; reply?: PostReply; conversationId?: string | null }> {
+    return this.request(`/api/widget/send/posts/${encodeURIComponent(campaignId)}/interactions`, {
+      method: 'POST',
+      body: value === undefined ? { kind } : { kind, value },
+    });
+  }
+
   /**
    * Does NOT store the returned token — the store persists it only once it
    * knows the identity op that asked for it is still current.
@@ -340,6 +367,11 @@ export class WidgetApiClient {
     return this.request('/api/widget/push-token', { method: 'POST', body: data });
   }
 
+  /** A Send push (`document_type: 'send_push'`) was tapped — counts as an open in Workstation. */
+  reportPushOpened(deliveryId: string): Promise<void> {
+    return this.request('/api/widget/push-opened', { method: 'POST', body: { deliveryId } });
+  }
+
   /** Logout passes the session's token explicitly and `skipReauth`. */
   removePushToken(
     token: string,

package/src/i18n.ts

@@ -157,6 +157,20 @@ export const DEFAULT_LABELS = {
   notificationNewReply: 'New reply',
   notificationAttachment: 'Sent an attachment',
   notificationOpenHint: 'Opens the conversation',
+  // Send posts over the app.
+  postFrom: '{name} from {workspace}',
+  postNewMessage: 'New message',
+  postOpenHint: 'Opens the message',
+  postClose: 'Close',
+  postMinimize: 'Minimize',
+  postReplyPlaceholder: 'Write a reply…',
+  postSend: 'Send',
+  postSent: 'Sent',
+  postReplyFailed: "Couldn't send your reply. Try again.",
+  postReactions: 'Reactions',
+  postThanks: 'Thanks for your feedback!',
+  postConversation: 'Your conversation',
+  postContinueChat: 'Continue in Messenger',
   // Rich blocks an agent can send.
   blockService: 'Service',
   blockProduct: 'Product',

package/src/index.tsx

@@ -33,6 +33,9 @@ export type {
   InAppNotification,
   Message,
   OutboundMessage,
+  PostInteractionKind,
+  PostReply,
+  PostThreadMessage,
   PreChatField,
   RepzoPickedFile,
   RepzoWidgetAttachmentOptions,
@@ -41,6 +44,7 @@ export type {
   WidgetAttachment,
   WidgetConfig,
   WidgetCustomAttributes,
+  WidgetPost,
   WidgetSpace,
   WidgetSpaceType,
   WidgetState,
@@ -152,6 +156,17 @@ export type RepzoWidgetType = {
    * installed, `boot({ push: { enabled: true } })` handles everything).
    */
   setPushToken(options: { token: string; platform?: 'ios' | 'android'; bundleId?: string }): Promise<void>;
+
+  /**
+   * Hand over a tapped notification your app read itself (Firebase's
+   * `getInitialNotification` / `onNotificationOpenedApp`, or a notification
+   * you re-posted locally). Returns true when it's a Repzo Widget push — it
+   * opens (now, or once the session is ready) and your app should skip its
+   * own routing; false for your app's own pushes.
+   *
+   * @since 1.2.1
+   */
+  handlePushNotification(message: { messageId?: string; data?: Record<string, unknown> }): boolean;
 };
 
 const RepzoWidget: RepzoWidgetType = {
@@ -198,6 +213,8 @@ const RepzoWidget: RepzoWidgetType = {
   setSecureStorageAdapter: (adapter) => setSecureStorageAdapter(adapter),
 
   setPushToken: (options) => controller.store.push.setManualToken(options),
+
+  handlePushNotification: (message) => controller.store.push.handleNotification(message),
 };
 
 export default RepzoWidget;

package/src/locales.ts

@@ -107,6 +107,19 @@ const ar: LabelMap = {
   notificationNewReply: 'رد جديد',
   notificationAttachment: 'أرسل مرفقًا',
   notificationOpenHint: 'يفتح المحادثة',
+  postFrom: '{name} من {workspace}',
+  postNewMessage: 'رسالة جديدة',
+  postOpenHint: 'يفتح الرسالة',
+  postClose: 'إغلاق',
+  postMinimize: 'تصغير',
+  postReplyPlaceholder: 'اكتب ردًا…',
+  postSend: 'إرسال',
+  postSent: 'تم الإرسال',
+  postReplyFailed: 'تعذّر إرسال ردك. حاول مرة أخرى.',
+  postReactions: 'التفاعلات',
+  postThanks: 'شكراً على ملاحظاتك!',
+  postConversation: 'محادثتك',
+  postContinueChat: 'تابع في المحادثة',
   blockService: 'خدمة',
   blockProduct: 'منتج',
   blockChooseTime: 'اختر وقتًا',

package/src/push/push-notifications.ts

@@ -15,6 +15,7 @@
 
 import { Platform } from 'react-native';
 import type { WidgetApiClient } from '../api/client';
+import { openExternalUrl } from '../ui/utils/safe-url';
 
 export interface WidgetPushOptions {
   /** Register this device for FCM pushes after every successful session init. */
@@ -90,6 +91,18 @@ function resolveMessaging(): MessagingHandle | null {
   }
 }
 
+const WIDGET_DOCUMENT_TYPES = new Set(['widget_message', 'send_post', 'send_push']);
+
+/** A push sent by Workstation for the widget (vs. one of the host app's own). */
+function isWidgetPush(data: any): data is Record<string, unknown> & { document_id: string } {
+  return (
+    !!data &&
+    WIDGET_DOCUMENT_TYPES.has(data.document_type) &&
+    typeof data.document_id === 'string' &&
+    !!data.document_id
+  );
+}
+
 export class PushManager {
   private options: WidgetPushOptions = {};
 
@@ -107,9 +120,16 @@ export class PushManager {
   /** Registrations still on the wire; unregister() waits for them. */
   private inflight = new Set<Promise<void>>();
 
+  /** Taps the host handed over before the session was ready; start() opens them. */
+  private pendingTaps: any[] = [];
+
+  /** The host and our own listener can both see one tap — open it once. */
+  private handledMessageIds = new Set<string>();
+
   constructor(
     private client: WidgetApiClient,
-    private openConversation: (conversationId: string) => void
+    private openConversation: (conversationId: string) => void,
+    private openPost: (campaignId: string) => void = () => {}
   ) {}
 
   /** Remember the boot options; actual work happens in start() post-init. */
@@ -124,6 +144,9 @@ export class PushManager {
    */
   async start(): Promise<void> {
     this.active = true;
+    const pending = this.pendingTaps;
+    this.pendingTaps = [];
+    pending.forEach((message) => this.handleTap(message));
     if (this.manualToken) {
       await this.register(this.manualToken);
     }
@@ -192,6 +215,8 @@ export class PushManager {
    */
   async unregister(authToken: string | null): Promise<void> {
     this.active = false;
+    // A tap held for this session must not open in the next user's.
+    this.pendingTaps = [];
     await Promise.all([...this.inflight]);
     const token = this.lastToken;
     this.lastToken = null;
@@ -227,27 +252,68 @@ export class PushManager {
   }
 
   private wireTapHandlers(messaging: MessagingHandle) {
+    // These listeners outlive logout, so taps go through the same session gate
+    // as host-forwarded ones: held until start(), and only marked handled then.
     // Background → tapped: the app was alive, just not in front.
     messaging.onNotificationOpenedApp((remoteMessage: any) => {
-      this.handleTap(remoteMessage);
+      this.handleNotification(remoteMessage);
     });
 
     // Killed → tapped: the click that launched the app.
     void messaging
       .getInitialNotification()
       .then((remoteMessage: any) => {
-        if (remoteMessage) this.handleTap(remoteMessage);
+        if (remoteMessage) this.handleNotification(remoteMessage);
       })
       .catch(() => {});
   }
 
-  /** Only widget pushes are ours — host app notifications pass through. */
+  /**
+   * A tap the host app read itself (`RepzoWidget.handlePushNotification`).
+   * Firebase hands out the notification that launched the app only once, so
+   * when the host reads it first our own listener gets nothing; the same goes
+   * for notifications the host re-posts locally while in the foreground.
+   * True when it's a widget push (so the host skips its own routing); it opens
+   * now, or once the session is ready.
+   */
+  handleNotification(message: any): boolean {
+    if (!isWidgetPush(message?.data)) return false;
+    if (this.active) this.handleTap(message);
+    else this.pendingTaps.push(message);
+    return true;
+  }
+
+  /**
+   * Only widget pushes are ours — host app notifications pass through. A team
+   * reply opens its conversation; a Send post opens the post; a Send mobile
+   * push reports the open and follows its link, if it has one.
+   */
   private handleTap(remoteMessage: any) {
     const data = remoteMessage?.data;
-    if (data?.document_type !== 'widget_message') return;
-    const conversationId = data?.document_id;
-    if (typeof conversationId === 'string' && conversationId) {
-      this.openConversation(conversationId);
+    if (!isWidgetPush(data)) return;
+    const messageId = remoteMessage?.messageId;
+    if (typeof messageId === 'string' && messageId) {
+      if (this.handledMessageIds.has(messageId)) return;
+      this.handledMessageIds.add(messageId);
+    }
+    const documentId = data.document_id;
+    if (data?.document_type === 'widget_message') this.openConversation(documentId);
+    else if (data?.document_type === 'send_post') this.openPost(documentId);
+    else if (data?.document_type === 'send_push') this.openSendPush(data);
+  }
+
+  /**
+   * The tap already opened the app. A link goes through the same gate as links
+   * in messages (`onOpenUrl` first, then web/mail/phone links), so the host can
+   * route `myapp://…` itself.
+   */
+  private openSendPush(data: Record<string, unknown>) {
+    const deliveryId = data.delivery_id;
+    if (typeof deliveryId === 'string' && deliveryId) {
+      this.client.reportPushOpened(deliveryId).catch(() => {
+        // Only the open count misses it; the visitor sees nothing.
+      });
     }
+    if (typeof data.url === 'string' && data.url) void openExternalUrl(data.url);
   }
 }