@octopus-community/react-native 1.0.8 → 1.9.1

package/src/types/sdkEvents.ts

@@ -0,0 +1,315 @@
+/**
+ * Types for SDK events emitted by Octopus SDK.
+ * These events represent various user interactions and system events within the Octopus community.
+ */
+
+/**
+ * Content types that can be included in a post
+ */
+export type PostContentType = 'text' | 'image' | 'poll';
+
+/**
+ * Content kind (post, comment, or reply)
+ */
+export type ContentKind = 'post' | 'comment' | 'reply';
+
+/**
+ * Reaction kinds
+ */
+export type ReactionKind =
+  | 'heart'
+  | 'joy'
+  | 'mouthOpen'
+  | 'clap'
+  | 'cry'
+  | 'rage'
+  | 'unknown';
+
+/**
+ * Report reasons for content or profile reporting
+ */
+export type ReportReason =
+  | 'hateSpeech'
+  | 'explicit'
+  | 'violence'
+  | 'spam'
+  | 'suicide'
+  | 'fakeProfile'
+  | 'childExploitation'
+  | 'intellectualProperty'
+  | 'other';
+
+/**
+ * Gamification actions that can gain points
+ */
+export type GamificationPointsGainedAction =
+  | 'post'
+  | 'comment'
+  | 'reply'
+  | 'reaction'
+  | 'vote'
+  | 'postCommented'
+  | 'profileCompleted'
+  | 'dailySession';
+
+/**
+ * Gamification actions that can remove points
+ */
+export type GamificationPointsRemovedAction =
+  | 'postDeleted'
+  | 'commentDeleted'
+  | 'replyDeleted'
+  | 'reactionDeleted';
+
+/**
+ * Source of a post click
+ */
+export type PostClickedSource = 'feed' | 'profile';
+
+/**
+ * Screen types displayed in the Octopus UI
+ */
+export type ScreenType =
+  | 'postsFeed'
+  | 'postDetail'
+  | 'commentDetail'
+  | 'createPost'
+  | 'profile'
+  | 'otherUserProfile'
+  | 'editProfile'
+  | 'reportContent'
+  | 'reportProfile'
+  | 'validateNickname'
+  | 'settingsList'
+  | 'settingsAccount'
+  | 'settingsAbout'
+  | 'reportExplanation'
+  | 'deleteAccount';
+
+/**
+ * Base interface for all SDK events
+ */
+export interface BaseSDKEvent {
+  type: string;
+}
+
+/**
+ * Event emitted when a post is created
+ */
+export interface PostCreatedEvent extends BaseSDKEvent {
+  type: 'postCreated';
+  postId: string;
+  content: PostContentType[];
+  topicId: string | null;
+  textLength: number;
+}
+
+/**
+ * Event emitted when a comment is created
+ */
+export interface CommentCreatedEvent extends BaseSDKEvent {
+  type: 'commentCreated';
+  commentId: string;
+  postId: string;
+  textLength: number;
+}
+
+/**
+ * Event emitted when a reply is created
+ */
+export interface ReplyCreatedEvent extends BaseSDKEvent {
+  type: 'replyCreated';
+  replyId: string;
+  commentId: string;
+  textLength: number;
+}
+
+/**
+ * Event emitted when content is deleted
+ */
+export interface ContentDeletedEvent extends BaseSDKEvent {
+  type: 'contentDeleted';
+  contentId: string;
+  contentKind: ContentKind;
+}
+
+/**
+ * Event emitted when a reaction is modified (added, changed, or removed)
+ */
+export interface ReactionModifiedEvent extends BaseSDKEvent {
+  type: 'reactionModified';
+  contentId: string;
+  contentKind: ContentKind;
+  previousReaction: ReactionKind | null;
+  newReaction: ReactionKind | null;
+}
+
+/**
+ * Event emitted when a poll is voted on
+ */
+export interface PollVotedEvent extends BaseSDKEvent {
+  type: 'pollVoted';
+  contentId: string;
+  optionId: string;
+}
+
+/**
+ * Event emitted when content is reported
+ */
+export interface ContentReportedEvent extends BaseSDKEvent {
+  type: 'contentReported';
+  contentId: string;
+  reasons: ReportReason[];
+}
+
+/**
+ * Event emitted when a profile is reported
+ */
+export interface ProfileReportedEvent extends BaseSDKEvent {
+  type: 'profileReported';
+  profileId: string;
+  reasons: ReportReason[];
+}
+
+/**
+ * Event emitted when gamification points are gained
+ */
+export interface GamificationPointsGainedEvent extends BaseSDKEvent {
+  type: 'gamificationPointsGained';
+  points: number;
+  action: GamificationPointsGainedAction;
+}
+
+/**
+ * Event emitted when gamification points are removed
+ */
+export interface GamificationPointsRemovedEvent extends BaseSDKEvent {
+  type: 'gamificationPointsRemoved';
+  points: number;
+  action: GamificationPointsRemovedAction;
+}
+
+/**
+ * Screen information for screen displayed events
+ */
+export interface ScreenInfo {
+  type: ScreenType;
+  feedId?: string;
+  relatedTopicId?: string | null;
+  postId?: string;
+  commentId?: string;
+  profileId?: string;
+}
+
+/**
+ * Event emitted when a screen is displayed
+ */
+export interface ScreenDisplayedEvent extends BaseSDKEvent {
+  type: 'screenDisplayed';
+  screen: ScreenInfo;
+}
+
+/**
+ * Event emitted when a notification is clicked
+ */
+export interface NotificationClickedEvent extends BaseSDKEvent {
+  type: 'notificationClicked';
+  notificationId: string;
+  contentId: string | null;
+}
+
+/**
+ * Event emitted when a post is clicked
+ */
+export interface PostClickedEvent extends BaseSDKEvent {
+  type: 'postClicked';
+  postId: string;
+  source: PostClickedSource;
+}
+
+/**
+ * Event emitted when the translation button is clicked
+ */
+export interface TranslationButtonClickedEvent extends BaseSDKEvent {
+  type: 'translationButtonClicked';
+  contentId: string;
+  viewTranslated: boolean;
+  contentKind: ContentKind;
+}
+
+/**
+ * Event emitted when the comment button is clicked
+ */
+export interface CommentButtonClickedEvent extends BaseSDKEvent {
+  type: 'commentButtonClicked';
+  postId: string;
+}
+
+/**
+ * Event emitted when the reply button is clicked
+ */
+export interface ReplyButtonClickedEvent extends BaseSDKEvent {
+  type: 'replyButtonClicked';
+  commentId: string;
+}
+
+/**
+ * Event emitted when the "see replies" button is clicked
+ */
+export interface SeeRepliesButtonClickedEvent extends BaseSDKEvent {
+  type: 'seeRepliesButtonClicked';
+  commentId: string;
+}
+
+/**
+ * Event emitted when a profile is modified
+ */
+export interface ProfileModifiedEvent extends BaseSDKEvent {
+  type: 'profileModified';
+  nicknameUpdated: boolean;
+  bioUpdated: boolean;
+  bioLength: number | null;
+  pictureUpdated: boolean;
+  hasPicture: boolean | null;
+}
+
+/**
+ * Event emitted when a session starts
+ */
+export interface SessionStartedEvent extends BaseSDKEvent {
+  type: 'sessionStarted';
+  sessionId: string;
+}
+
+/**
+ * Event emitted when a session stops
+ */
+export interface SessionStoppedEvent extends BaseSDKEvent {
+  type: 'sessionStopped';
+  sessionId: string;
+}
+
+/**
+ * Union type of all possible SDK events
+ */
+export type SDKEvent =
+  | PostCreatedEvent
+  | CommentCreatedEvent
+  | ReplyCreatedEvent
+  | ContentDeletedEvent
+  | ReactionModifiedEvent
+  | PollVotedEvent
+  | ContentReportedEvent
+  | ProfileReportedEvent
+  | GamificationPointsGainedEvent
+  | GamificationPointsRemovedEvent
+  | ScreenDisplayedEvent
+  | NotificationClickedEvent
+  | PostClickedEvent
+  | TranslationButtonClickedEvent
+  | CommentButtonClickedEvent
+  | ReplyButtonClickedEvent
+  | SeeRepliesButtonClickedEvent
+  | ProfileModifiedEvent
+  | SessionStartedEvent
+  | SessionStoppedEvent;

package/src/types/urlOpeningStrategy.ts

@@ -0,0 +1,20 @@
+/**
+ * Strategy for handling URLs tapped inside the Octopus Community UI.
+ *
+ * When URL interception is enabled via `openUI({ interceptUrls: true })`,
+ * the app receives each tapped URL via `addNavigateToUrlListener`. The callback
+ * returns one of these strategies to decide who handles the URL.
+ */
+export enum UrlOpeningStrategy {
+  /**
+   * The URL has been handled by the app. The SDK will not open it.
+   * Use this when you open the URL in an in-app web view or handle it yourself.
+   */
+  handledByApp = 'handledByApp',
+
+  /**
+   * The URL should be opened by the Octopus SDK (system browser).
+   * The native layer will open the URL in the default browser when this is returned.
+   */
+  handledByOctopus = 'handledByOctopus',
+}

package/src/updateNotSeenNotificationsCount.ts

@@ -0,0 +1,30 @@
+import { OctopusReactNativeSdk } from './internals/nativeModule';
+
+/**
+ * Force refresh the unseen notification count from the server.
+ *
+ * This method triggers a manual update of the notification badge count.
+ * The updated count will be emitted via the notSeenNotificationsCountChanged event.
+ * Use `addNotSeenNotificationsCountListener` to listen for count changes.
+ *
+ * @returns A promise that resolves when the update is complete.
+ * @throws An error if the SDK is not initialized or if the update fails.
+ *
+ * @example
+ * ```typescript
+ * // Listen to count changes
+ * const subscription = addNotSeenNotificationsCountListener((count) => {
+ *   console.log(`Unseen notifications: ${count}`);
+ *   // Update your badge UI
+ * });
+ *
+ * // Manually refresh the count
+ * await updateNotSeenNotificationsCount();
+ *
+ * // Later, unsubscribe
+ * subscription.remove();
+ * ```
+ */
+export function updateNotSeenNotificationsCount(): Promise<void> {
+  return OctopusReactNativeSdk.updateNotSeenNotificationsCount();
+}

package/android/src/main/java/com/octopuscommunity/octopusreactnativesdk/OctopusReactNativeSdkModule.kt

@@ -1,155 +0,0 @@
-package com.octopuscommunity.octopusreactnativesdk
-
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.bridge.Promise
-import com.facebook.react.bridge.ReadableMap
-
-class OctopusReactNativeSdkModule(reactContext: ReactApplicationContext) :
-  ReactContextBaseJavaModule(reactContext) {
-
-  private val sdkInitializer = OctopusSDKInitializer()
-  private val eventEmitter = OctopusEventEmitter(reactContext)
-  private val uiController = OctopusUIController(reactContext)
-  private val ssoAuthenticator = OctopusSSOAuthenticator(reactContext, eventEmitter)
-
-  override fun getName(): String = NAME
-
-  @ReactMethod
-  fun initialize(options: ReadableMap, promise: Promise) {
-    sdkInitializer.initialize(reactApplicationContext, options, promise)
-  }
-
-  @ReactMethod
-  fun openUI(promise: Promise) {
-    uiController.openUI(promise)
-  }
-
-  @ReactMethod
-  fun closeUI(promise: Promise) {
-    uiController.closeUI(promise)
-  }
-
-  @ReactMethod
-  fun connectUser(params: ReadableMap, promise: Promise) {
-    ssoAuthenticator.connectUser(params, promise)
-  }
-
-  @ReactMethod
-  fun disconnectUser(promise: Promise) {
-    ssoAuthenticator.disconnectUser(promise)
-  }
-
-  @ReactMethod
-  fun completeUserTokenRequest(requestId: String, token: String, promise: Promise) {
-    ssoAuthenticator.completeTokenRequest(requestId, token)
-    promise.resolve(null)
-  }
-
-  @ReactMethod
-  fun cancelUserTokenRequest(requestId: String, promise: Promise) {
-    ssoAuthenticator.cancelTokenRequest(requestId)
-    promise.resolve(null)
-  }
-
-  @ReactMethod
-  fun addListener(eventName: String) {
-    eventEmitter.addListener(eventName)
-  }
-
-  @ReactMethod
-  fun removeListeners(count: Int) {
-    eventEmitter.removeListeners(count)
-  }
-
-  @ReactMethod
-  fun updateColorScheme(colorScheme: String?, promise: Promise) {
-    // Update the theme config with the new color scheme
-    val currentThemeConfig = OctopusThemeManager.getThemeConfig()
-    if (currentThemeConfig != null) {
-      val updatedThemeConfig = currentThemeConfig.copy(colorScheme = colorScheme)
-      OctopusThemeManager.setThemeConfig(updatedThemeConfig)
-    }
-    promise.resolve(null)
-  }
-
-  @ReactMethod
-  fun updateTheme(themeOptions: ReadableMap, promise: Promise) {
-    try {
-      // Parse theme using the standard initializer
-      val themeConfig = sdkInitializer.parseThemeConfig(themeOptions)
-      OctopusThemeManager.setThemeConfig(themeConfig)
-      promise.resolve(null)
-    } catch (e: Exception) {
-      promise.reject("UPDATE_THEME_ERROR", "Failed to update theme", e)
-    }
-  }
-
-  private fun parseColor(colorString: String?): String? {
-    if (colorString == null) return null
-
-    return try {
-      // Validate that the color string is a valid hex color
-      android.graphics.Color.parseColor(colorString)
-      // Return the original string if parsing succeeds
-      colorString
-    } catch (e: IllegalArgumentException) {
-      // Invalid color format - return null to skip this color
-      null
-    }
-  }
-
-  private fun parseFontsConfig(fontsMap: ReadableMap): OctopusFontsConfig? {
-    // Use pre-processed configuration from TypeScript layer
-    val parsedConfig = fontsMap.getMap("parsedConfig")
-    if (parsedConfig != null) {
-      return parsePreProcessedFontsConfig(parsedConfig)
-    }
-
-    return null
-  }
-
-  private fun parsePreProcessedFontsConfig(parsedConfig: ReadableMap): OctopusFontsConfig? {
-    val textStylesMap = parsedConfig.getMap("textStyles")
-    val textStyles = mutableMapOf<String, OctopusTextStyleConfig>()
-
-    // Parse pre-processed font configuration from TypeScript layer
-    textStylesMap?.let { textStylesMap ->
-      val textStyleKeys = arrayOf("title1", "title2", "body1", "body2", "caption1", "caption2")
-
-      textStyleKeys.forEach { key ->
-        val textStyleMap = textStylesMap.getMap(key)
-        textStyleMap?.let { style ->
-          val fontType = style.getString("fontType")
-          val fontSize = if (style.hasKey("fontSize")) style.getDouble("fontSize") else Double.NaN
-
-          if (fontType != null || (!fontSize.isNaN() && fontSize > 0)) {
-            textStyles[key] = OctopusTextStyleConfig(
-              fontType = fontType,
-              fontSize = if (fontSize.isNaN() || fontSize <= 0) null else fontSize
-            )
-          }
-        }
-      }
-    }
-
-    // Only create fonts config if we have text styles
-    if (textStyles.isNotEmpty()) {
-      return OctopusFontsConfig(
-        textStyles = textStyles
-      )
-    }
-
-    return null
-  }
-
-
-  companion object {
-    const val NAME = "OctopusReactNativeSdk"
-  }
-
-  init {
-    OctopusEventEmitter.instance = eventEmitter
-  }
-}