@adobe/react-native-aepmessaging 7.3.0 → 7.4.0

package/src/ui/utils/inboxStorage.spec.tsx

@@ -0,0 +1,136 @@
+/*
+    Copyright 2026 Adobe. All rights reserved.
+    This file is licensed to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law
+    or agreed to in writing, software distributed under the License is
+    distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS OF
+    ANY KIND, either express or implied. See the License for the specific language
+    governing permissions and limitations under the License.
+*/
+
+import { NativeModules } from 'react-native';
+import { loadInboxState, saveInboxState } from './inboxStorage';
+
+jest.mock('react-native', () => ({
+  NativeModules: {
+    AEPMessaging: {
+      getInboxState: jest.fn(),
+      setInboxState: jest.fn(),
+    },
+  },
+}));
+
+describe('inboxStorage', () => {
+  const activityId = 'activity-123';
+  const aep = NativeModules.AEPMessaging as {
+    getInboxState: jest.Mock;
+    setInboxState: jest.Mock;
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    aep.getInboxState.mockReset();
+    aep.setInboxState.mockReset();
+    aep.getInboxState = jest.fn();
+    aep.setInboxState = jest.fn();
+  });
+
+  describe('loadInboxState', () => {
+    it('returns empty state when activityId is empty', async () => {
+      await expect(loadInboxState('')).resolves.toEqual({
+        dismissed: [],
+        interacted: [],
+      });
+      expect(aep.getInboxState).not.toHaveBeenCalled();
+    });
+
+    it('returns empty state when getInboxState is not available', async () => {
+      const prev = aep.getInboxState;
+      delete (aep as any).getInboxState;
+
+      await expect(loadInboxState(activityId)).resolves.toEqual({
+        dismissed: [],
+        interacted: [],
+      });
+
+      aep.getInboxState = prev;
+    });
+
+    it('parses JSON from native and returns dismissed and interacted', async () => {
+      aep.getInboxState.mockResolvedValue(
+        JSON.stringify({ dismissed: ['a', 'b'], interacted: ['c'] })
+      );
+
+      await expect(loadInboxState(activityId)).resolves.toEqual({
+        dismissed: ['a', 'b'],
+        interacted: ['c'],
+      });
+      expect(aep.getInboxState).toHaveBeenCalledWith(activityId);
+    });
+
+    it('returns empty arrays when native returns non-string', async () => {
+      aep.getInboxState.mockResolvedValue(null);
+
+      await expect(loadInboxState(activityId)).resolves.toEqual({
+        dismissed: [],
+        interacted: [],
+      });
+    });
+
+    it('returns empty arrays when JSON is invalid', async () => {
+      aep.getInboxState.mockResolvedValue('not-json');
+
+      await expect(loadInboxState(activityId)).resolves.toEqual({
+        dismissed: [],
+        interacted: [],
+      });
+    });
+
+    it('normalizes non-array dismissed/interacted in parsed JSON', async () => {
+      aep.getInboxState.mockResolvedValue(JSON.stringify({ dismissed: 'bad', interacted: 1 }));
+
+      await expect(loadInboxState(activityId)).resolves.toEqual({
+        dismissed: [],
+        interacted: [],
+      });
+    });
+  });
+
+  describe('saveInboxState', () => {
+    it('no-ops when activityId is empty', async () => {
+      await saveInboxState('', { dismissed: ['x'], interacted: [] });
+      expect(aep.setInboxState).not.toHaveBeenCalled();
+    });
+
+    it('no-ops when setInboxState is not available', async () => {
+      const prev = aep.setInboxState;
+      delete (aep as any).setInboxState;
+
+      await saveInboxState(activityId, { dismissed: [], interacted: [] });
+
+      aep.setInboxState = prev;
+    });
+
+    it('calls native setInboxState with stringified state', async () => {
+      const state = { dismissed: ['d1'], interacted: ['i1'] };
+      aep.setInboxState.mockResolvedValue(undefined);
+
+      await saveInboxState(activityId, state);
+
+      expect(aep.setInboxState).toHaveBeenCalledWith(
+        activityId,
+        JSON.stringify(state)
+      );
+    });
+
+    it('swallows errors from setInboxState', async () => {
+      aep.setInboxState.mockRejectedValue(new Error('disk full'));
+
+      await expect(
+        saveInboxState(activityId, { dismissed: [], interacted: [] })
+      ).resolves.toBeUndefined();
+    });
+  });
+});

package/src/ui/utils/inboxStorage.ts

@@ -0,0 +1,64 @@
+/*
+Copyright 2026 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions under the License.
+*/
+
+import { NativeModules } from 'react-native';
+
+export interface InboxPersistedState {
+  dismissed: string[];
+  interacted: string[];
+}
+
+const RCTAEPMessaging = NativeModules.AEPMessaging;
+
+/**
+ * Load persisted inbox state (dismissed and read card IDs) from native storage.
+ * Uses scopeDetails.activity.id as the key - this is constant across server responses.
+ * Persists via SharedPreferences (Android) / UserDefaults (iOS) - no AsyncStorage needed.
+ * @param activityId - From scopeDetails.activity in the inbox proposition
+ * @returns Persisted state or empty defaults if not found
+ */
+export async function loadInboxState(
+  activityId: string
+): Promise<InboxPersistedState> {
+  if (!activityId || !RCTAEPMessaging?.getInboxState) {
+    return { dismissed: [], interacted: [] };
+  }
+  try {
+    const raw = await RCTAEPMessaging.getInboxState(activityId);
+    if (!raw || typeof raw !== 'string') return { dismissed: [], interacted: [] };
+    const parsed = JSON.parse(raw) as InboxPersistedState;
+    return {
+      dismissed: Array.isArray(parsed?.dismissed) ? parsed.dismissed : [],
+      interacted: Array.isArray(parsed?.interacted) ? parsed.interacted : [],
+    };
+  } catch {
+    return { dismissed: [], interacted: [] };
+  }
+}
+
+/**
+ * @experimental First React Native inbox UI — subject to change while we expand testing.
+ * Save inbox state to native storage for persistence across app launches.
+ * @param activityId - From scopeDetails.activity in the inbox proposition
+ * @param state - Dismissed and interacted card IDs to persist
+ */
+export async function saveInboxState(
+  activityId: string,
+  state: InboxPersistedState
+): Promise<void> {
+  if (!activityId || !RCTAEPMessaging?.setInboxState) return;
+  try {
+    await RCTAEPMessaging.setInboxState(activityId, JSON.stringify(state));
+  } catch {
+    // Silently fail - persistence is best-effort
+  }
+}

package/src/ui/utils/index.ts

@@ -0,0 +1,3 @@
+export { generateCardHash } from './generateCardHash';
+export { loadInboxState, saveInboxState } from './inboxStorage';
+