react-native-insider 7.1.0 → 8.0.0

package/src/InsiderAppCard.js

@@ -0,0 +1,290 @@
+import InsiderAppCards from './InsiderAppCards';
+import { resolveWithCallback } from './Util';
+
+class InsiderAppCardContent {
+  #title;
+  #description;
+
+  constructor({ title, description }) {
+    this.#title = title;
+    this.#description = description;
+  }
+
+  get title() {
+    return this.#title;
+  }
+
+  get description() {
+    return this.#description;
+  }
+}
+
+class InsiderAppCardImage {
+  #url;
+
+  constructor({ url }) {
+    this.#url = url;
+  }
+
+  get url() {
+    return this.#url;
+  }
+}
+
+class InsiderAppCardButton {
+  #data;
+  #buttonId;
+  #appCardId;
+  #text;
+  #action;
+
+  constructor(appCardId, data) {
+    this.#data = data;
+    this.#buttonId = data.id;
+    this.#appCardId = appCardId;
+    this.#text = data.text;
+    this.#action = InsiderAppCardAction.fromData(data.action);
+  }
+
+  get buttonId() {
+    return this.#buttonId;
+  }
+
+  get appCardId() {
+    return this.#appCardId;
+  }
+
+  get text() {
+    return this.#text;
+  }
+
+  get action() {
+    return this.#action;
+  }
+
+  get data() {
+    return this.#data;
+  }
+
+  click() {
+    InsiderAppCards.clickButton(this);
+  }
+}
+
+class InsiderAppCardAction {
+  #type;
+
+  constructor({ type }) {
+    this.#type = type;
+  }
+
+  get type() {
+    return this.#type;
+  }
+
+  static fromData(data) {
+    if (!data) return null;
+
+    switch (data.type) {
+      case 'deep_link':
+        return new InsiderAppCardDeeplinkAction(data);
+      case 'feedback':
+        return new InsiderAppCardFeedbackAction(data);
+      case 'open_settings':
+        return new InsiderAppCardOpenSettingsAction(data);
+      default:
+        return null;
+    }
+  }
+
+  runAction() {
+    throw new Error('runAction() must be implemented by subclasses');
+  }
+}
+
+class InsiderAppCardDeeplinkAction extends InsiderAppCardAction {
+  #urlScheme;
+  #internalBrowserUrl;
+  #externalBrowserUrl;
+  #json;
+  #keysAndValues;
+
+  constructor(data) {
+    super({ type: 'deep_link' });
+    this.#urlScheme = data.url_scheme;
+    this.#internalBrowserUrl = data.internal_browser_url;
+    this.#externalBrowserUrl = data.external_browser_url;
+    this.#json = data.json;
+    this.#keysAndValues = data.key_value;
+  }
+
+  get url() {
+    if (this.#urlScheme && this.#urlScheme.length > 0)
+      return this.#urlScheme;
+    else if (this.#internalBrowserUrl && this.#internalBrowserUrl.length > 0)
+      return this.#internalBrowserUrl;
+    else if (this.#externalBrowserUrl && this.#externalBrowserUrl.length > 0)
+      return this.#externalBrowserUrl;
+    else
+      return null;
+  }
+
+  get deeplinkType() {
+    if (this.#urlScheme && this.#urlScheme.length > 0)
+      return 'url_scheme';
+    else if (this.#internalBrowserUrl && this.#internalBrowserUrl.length > 0)
+      return 'internal';
+    else if (this.#externalBrowserUrl && this.#externalBrowserUrl.length > 0)
+      return 'external';
+    else
+      return 'unknown';
+  }
+
+  get json() {
+    return this.#json ? JSON.parse(this.#json) : null;
+  }
+
+  get keysAndValues() {
+    return this.#keysAndValues;
+  }
+}
+
+class InsiderAppCardOpenSettingsAction extends InsiderAppCardAction {
+  constructor() {
+    super({ type: 'open_settings' });
+  }
+
+}
+
+class InsiderAppCardFeedbackAction extends InsiderAppCardAction {
+  constructor() {
+    super({ type: 'feedback' });
+  }
+}
+
+class InsiderAppCard {
+  #data;
+  #appCardId;
+  #type;
+  #isRead;
+  #images;
+  #content;
+  #buttons;
+  #action;
+
+  constructor(data) {
+    this.#data = data;
+    this.#appCardId = data.id;
+    this.#type = data.type;
+    this.#isRead = data.read;
+    this.#images = data.images ? data.images.map(x => new InsiderAppCardImage(x)) : null;
+    this.#content = data.content ? new InsiderAppCardContent(data.content) : null;
+    this.#buttons = data.buttons ? data.buttons.map(x => new InsiderAppCardButton(data.id, x)) : null;
+    this.#action = InsiderAppCardAction.fromData(data.action);
+  }
+
+  get appCardId() {
+    return this.#appCardId;
+  }
+
+  get type() {
+    return this.#type;
+  }
+
+  get isRead() {
+    return this.#isRead;
+  }
+
+  get images() {
+    return this.#images;
+  }
+
+  get content() {
+    return this.#content;
+  }
+
+  get buttons() {
+    return this.#buttons;
+  }
+
+  get action() {
+    return this.#action;
+  }
+
+  get data() {
+    return JSON.parse(JSON.stringify(this.#data));
+  }
+
+  markAsRead(completion) {
+    const promise = new Promise((resolve, reject) => {
+      InsiderAppCards.markAsRead([this.appCardId], error => {
+        if (error) reject(error);
+        else {
+          this.#isRead = true;
+          resolve();
+        }
+      });
+    });
+
+    return resolveWithCallback(promise, completion);
+  }
+
+  markAsUnread(completion) {
+    const promise = new Promise((resolve, reject) => {
+      InsiderAppCards.markAsUnread([this.appCardId], error => {
+        if (error) reject(error);
+        else {
+          this.#isRead = false;
+          resolve();
+        }
+      });
+    });
+
+    return resolveWithCallback(promise, completion);
+  }
+
+  delete(completion) {
+    const promise = new Promise((resolve, reject) => {
+      InsiderAppCards.delete([this.appCardId], error => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+
+    return resolveWithCallback(promise, completion);
+  }
+
+  view() {
+    InsiderAppCards.view(this);
+  }
+
+  click() {
+    InsiderAppCards.click(this);
+  }
+}
+
+class InsiderAppCardsCampaignResponse {
+  #appCards;
+
+  constructor({ items }) {
+    this.#appCards = items?.map(x => new InsiderAppCard(x));
+  }
+
+  get appCards() {
+    return this.#appCards;
+  }
+}
+
+export {
+  InsiderAppCardContent,
+  InsiderAppCardImage,
+  InsiderAppCardButton,
+
+  InsiderAppCardAction,
+  InsiderAppCardDeeplinkAction,
+  InsiderAppCardOpenSettingsAction,
+  InsiderAppCardFeedbackAction,
+
+  InsiderAppCard,
+  InsiderAppCardsCampaignResponse,
+};

package/src/InsiderAppCards.d.ts

@@ -0,0 +1,268 @@
+import {
+	InsiderAppCardsCampaignResponse,
+	InsiderAppCard,
+	InsiderAppCardButton,
+} from './InsiderAppCard';
+
+/**
+ * Main API for accessing and managing app cards (campaigns) functionality.
+ *
+ * This interface provides methods to retrieve app card campaigns and notifications
+ * from the Insider platform. App cards can contain text, images, and
+ * interactive buttons.
+ *
+ * The app cards API allows you to:
+ * - Fetch app card campaigns with their content and metadata
+ * - Access app card read/unread status
+ * - Handle interactive buttons within app cards
+ * - Support multiple content types (text, images)
+ */
+interface InsiderAppCards {
+	/**
+	 * Retrieves the user's app card campaigns.
+	 *
+	 * Fetches all available app cards from the Insider platform for the current user.
+	 * This method cancels any pending campaign requests before initiating a new one.
+	 *
+	 * The campaign response contains app cards that may include:
+	 * - Marketing notifications and promotional content
+	 * - Multi-media content (text, images)
+	 * - Interactive buttons with associated actions
+	 * - Read/unread status for each app card
+	 *
+	 * @param completion - A completion handler called when the campaigns are retrieved or an error occurs.
+	 * The completion handler takes two parameters:
+	 * - error: An error object if the request fails, undefined otherwise.
+	 * - campaignResponse: An InsiderAppCardsCampaignResponse containing the user's app cards. Will be undefined if an error occurred.
+	 *
+	 * @example
+	 * ```typescript
+	 * appCards.getCampaigns((error, campaignResponse) => {
+	 *   if (error) {
+	 *     console.log('Failed to fetch campaigns:', error.message);
+	 *   } else {
+	 *     campaignResponse.appCards.forEach(appCard => {
+	 *       console.log('App Card Id:', appCard.appCardId, 'Read:', appCard.isRead);
+	 *     });
+	 *   }
+	 * });
+	 * ```
+	 */
+	getCampaigns(completion: (error?: Error, campaignResponse?: InsiderAppCardsCampaignResponse) => void): void;
+
+	/**
+	 * Retrieves the user's app card campaigns and returns a promise.
+	 *
+	 * Fetches all available app cards from the Insider platform for the current user.
+	 * This method cancels any pending campaign requests before initiating a new one.
+	 *
+	 * @returns A Promise that resolves with the campaign response or rejects with an error.
+	 *
+	 * @example
+	 * ```typescript
+	 * try {
+	 *   const campaignResponse = await appCards.getCampaigns();
+	 *   campaignResponse.appCards.forEach(appCard => {
+	 *     console.log('App Card Id:', appCard.appCardId, 'Read:', appCard.isRead);
+	 *   });
+	 * } catch (error) {
+	 *   console.log('Failed to fetch campaigns:', error.message);
+	 * }
+	 * ```
+	 */
+	getCampaigns(): Promise<InsiderAppCardsCampaignResponse>;
+
+	/**
+	 * Marks specified app cards as read.
+	 *
+	 * Updates the read status of one or more app cards to indicate they have been viewed by the user.
+	 * This operation synchronizes with the Insider backend to persist the read state across devices.
+	 *
+	 * @param appCardIds - An array of app card identifiers to mark as read. Each Id should correspond to a valid
+	 * app card Id from the campaigns. Empty arrays are allowed but will result in no operation.
+	 * @param completion - A completion handler called when the operation finishes.
+	 * The completion handler takes one parameter:
+	 * - error: An error object if the request fails, undefined if successful.
+	 *
+	 * @example
+	 * ```typescript
+	 * appCards.markAsRead(['card_123', 'card_456'], (error) => {
+	 *   if (error) {
+	 *     console.log('Failed to mark app cards as read:', error.message);
+	 *   } else {
+	 *     console.log('App cards marked as read successfully');
+	 *   }
+	 * });
+	 * ```
+	 *
+	 * @remarks App card Ids that don't exist are silently ignored.
+	 */
+	markAsRead(appCardIds: string[], completion: (error?: Error) => void): void;
+
+	/**
+	 * Marks specified app cards as read and returns a promise.
+	 *
+	 * Updates the read status of one or more app cards to indicate they have been viewed by the user.
+	 * This operation synchronizes with the Insider backend to persist the read state across devices.
+	 *
+	 * @param appCardIds - An array of app card identifiers to mark as read. Each Id should correspond to a valid
+	 * app card Id from the campaigns. Empty arrays are allowed but will result in no operation.
+	 * @returns A Promise that resolves when successful or rejects with an error.
+	 *
+	 * @example
+	 * ```typescript
+	 * try {
+	 *   await appCards.markAsRead(['card_123', 'card_456']);
+	 *   console.log('App cards marked as read successfully');
+	 * } catch (error) {
+	 *   console.log('Failed to mark app cards as read:', error.message);
+	 * }
+	 * ```
+	 *
+	 * @remarks App card Ids that don't exist are silently ignored.
+	 */
+	markAsRead(appCardIds: string[]): Promise<void>;
+
+	/**
+	 * Marks specified app cards as unread.
+	 *
+	 * Updates the read status of one or more app cards to indicate they are unread.
+	 * This operation synchronizes with the Insider backend to persist the unread state across devices.
+	 *
+	 * @param appCardIds - An array of app card identifiers to mark as unread. Each Id should correspond to a valid
+	 * app card Id from the campaigns. Empty arrays are allowed but will result in no operation.
+	 * @param completion - A completion handler called when the operation finishes.
+	 * The completion handler takes one parameter:
+	 * - error: An error object if the request fails, undefined if successful.
+	 *
+	 * @example
+	 * ```typescript
+	 * appCards.markAsUnread(['card_123', 'card_456'], (error) => {
+	 *   if (error) {
+	 *     console.log('Failed to mark app cards as unread:', error.message);
+	 *   } else {
+	 *     console.log('App cards marked as unread successfully');
+	 *   }
+	 * });
+	 * ```
+	 *
+	 * @remarks App card Ids that don't exist are silently ignored.
+	 */
+	markAsUnread(appCardIds: string[], completion: (error?: Error) => void): void;
+
+	/**
+	 * Marks specified app cards as unread and returns a promise.
+	 *
+	 * Updates the read status of one or more app cards to indicate they are unread.
+	 * This operation synchronizes with the Insider backend to persist the unread state across devices.
+	 *
+	 * @param appCardIds - An array of app card identifiers to mark as unread. Each Id should correspond to a valid
+	 * app card Id from the campaigns. Empty arrays are allowed but will result in no operation.
+	 * @returns A Promise that resolves when successful or rejects with an error.
+	 *
+	 * @example
+	 * ```typescript
+	 * try {
+	 *   await appCards.markAsUnread(['card_123', 'card_456']);
+	 *   console.log('App cards marked as unread successfully');
+	 * } catch (error) {
+	 *   console.log('Failed to mark app cards as unread:', error.message);
+	 * }
+	 * ```
+	 *
+	 * @remarks App card Ids that don't exist are silently ignored.
+	 */
+	markAsUnread(appCardIds: string[]): Promise<void>;
+
+	/**
+	 * Deletes specified app cards.
+	 *
+	 * Permanently removes one or more app cards from the user's campaigns.
+	 * This operation synchronizes with the Insider backend.
+	 *
+	 * @param appCardIds - An array of app card identifiers to delete.
+	 * @param completion - A completion handler called when the operation finishes.
+	 *
+	 * @example
+	 * ```typescript
+	 * appCards.delete(['card_123', 'card_456'], (error) => {
+	 *   if (error) {
+	 *     console.log('Failed to delete app cards:', error.message);
+	 *   } else {
+	 *     console.log('App cards deleted successfully');
+	 *   }
+	 * });
+	 * ```
+	 */
+	delete(appCardIds: string[], completion: (error?: Error) => void): void;
+
+	/**
+	 * Deletes specified app cards and returns a promise.
+	 *
+	 * Permanently removes one or more app cards from the user's campaigns.
+	 * This operation synchronizes with the Insider backend.
+	 *
+	 * @param appCardIds - An array of app card identifiers to delete.
+	 * @returns A Promise that resolves when successful or rejects with an error.
+	 *
+	 * @example
+	 * ```typescript
+	 * try {
+	 *   await appCards.delete(['card_123', 'card_456']);
+	 *   console.log('App cards deleted successfully');
+	 * } catch (error) {
+	 *   console.log('Failed to delete app cards:', error.message);
+	 * }
+	 * ```
+	 */
+	delete(appCardIds: string[]): Promise<void>;
+
+	/**
+	 * Records a view event for an app card.
+	 *
+	 * Call this method when a user views an app card.
+	 * This notifies observers and can be used for analytics tracking.
+	 *
+	 * @param appCard - The app card that was viewed.
+	 *
+	 * @example
+	 * ```typescript
+	 * appCards.view(appCard);
+	 * ```
+	 */
+	view(appCard: InsiderAppCard): void;
+
+	/**
+	 * Records a click event for an app card.
+	 *
+	 * Call this method when a user clicks or taps on an app card.
+	 * This executes the app card's deeplink action (if present) and notifies observers.
+	 *
+	 * @param appCard - The app card that was clicked.
+	 *
+	 * @example
+	 * ```typescript
+	 * appCards.click(appCard);
+	 * ```
+	 */
+	click(appCard: InsiderAppCard): void;
+
+	/**
+	 * Records a click event for a button within an app card.
+	 *
+	 * Call this method when a user clicks or taps on a button in an app card.
+	 * This executes the button's action (if present) and notifies observers.
+	 *
+	 * @param button - The button that was clicked.
+	 *
+	 * @example
+	 * ```typescript
+	 * appCards.clickButton(button);
+	 * ```
+	 */
+	clickButton(button: InsiderAppCardButton): void;
+}
+
+declare const InsiderAppCards: InsiderAppCards;
+
+export default InsiderAppCards;

package/src/InsiderAppCards.js

@@ -0,0 +1,98 @@
+import { NativeModules } from 'react-native';
+import { resolveWithCallback } from './Util';
+import { InsiderAppCardsCampaignResponse, InsiderAppCardButton, InsiderAppCard } from './InsiderAppCard';
+import { InsiderAppCardsError, InsiderAppCardsErrorCode } from './InsiderAppCardsError';
+
+const Insider = NativeModules.RNInsider;
+
+const InsiderAppCards = Object.freeze({
+  getCampaigns(completion) {
+    const promise = new Promise((resolve, reject) => {
+      Insider.getAppCardsCampaigns((error, result) => {
+        if (error) reject(InsiderAppCardsError.from(error));
+        else resolve(new InsiderAppCardsCampaignResponse(result));
+      });
+    });
+
+    return resolveWithCallback(promise, completion);
+  },
+  markAsRead(appCardIds, completion) {
+    const promise = new Promise((resolve, reject) => {
+      if (
+        !Array.isArray(appCardIds) ||
+        appCardIds.length === 0 ||
+        appCardIds.some(id => typeof id !== 'string')
+      ) {
+        reject(new InsiderAppCardsError(InsiderAppCardsErrorCode.INVALID_PARAMETER, 'appCardIds must be a non-empty array of strings.'));
+        return;
+      }
+
+      Insider.markAppCardsAsRead(appCardIds, (error) => {
+        if (error) reject(InsiderAppCardsError.from(error));
+        else resolve();
+      });
+    });
+
+    return resolveWithCallback(promise, completion);
+  },
+  markAsUnread(appCardIds, completion) {
+    const promise = new Promise((resolve, reject) => {
+      if (
+        !Array.isArray(appCardIds) ||
+        appCardIds.length === 0 ||
+        appCardIds.some(id => typeof id !== 'string')
+      ) {
+        reject(new InsiderAppCardsError(InsiderAppCardsErrorCode.INVALID_PARAMETER, 'appCardIds must be a non-empty array of strings.'));
+        return;
+      }
+
+      Insider.markAppCardsAsUnread(appCardIds, (error) => {
+        if (error) reject(InsiderAppCardsError.from(error));
+        else resolve();
+      });
+    });
+
+    return resolveWithCallback(promise, completion);
+  },
+  delete(appCardIds, completion) {
+    const promise = new Promise((resolve, reject) => {
+      if (
+        !Array.isArray(appCardIds) ||
+        appCardIds.length === 0 ||
+        appCardIds.some(id => typeof id !== 'string')
+      ) {
+        reject(new InsiderAppCardsError(InsiderAppCardsErrorCode.INVALID_PARAMETER, 'appCardIds must be a non-empty array of strings.'));
+        return;
+      }
+
+      Insider.deleteAppCards(appCardIds, (error) => {
+        if (error) reject(InsiderAppCardsError.from(error));
+        else resolve();
+      });
+    });
+
+    return resolveWithCallback(promise, completion);
+  },
+  view(appCard) {
+    if (!(appCard instanceof InsiderAppCard)) {
+      throw new InsiderAppCardsError(InsiderAppCardsErrorCode.INVALID_PARAMETER, `appCard must be of type InsiderAppCard, received: ${typeof appCard}`);
+    }
+
+    Insider.viewAppCard(appCard.data);
+  },
+  click(appCard) {
+    if (!(appCard instanceof InsiderAppCard)) {
+      throw new InsiderAppCardsError(InsiderAppCardsErrorCode.INVALID_PARAMETER, `appCard must be of type InsiderAppCard, received: ${typeof appCard}`);
+    }
+
+    Insider.clickAppCard(appCard.data);
+  },
+  clickButton(button) {
+    if (!(button instanceof InsiderAppCardButton)) {
+      throw new InsiderAppCardsError(InsiderAppCardsErrorCode.INVALID_PARAMETER, `button must be of type InsiderAppCardButton, received: ${typeof button}`);
+    }
+    Insider.clickAppCardButton(button.appCardId, button.data);
+  },
+});
+
+export default InsiderAppCards;