@100mslive/react-native-hms 1.9.9 → 1.9.10

package/src/classes/polls/HMSPollUserTrackingMode.ts

@@ -0,0 +1,16 @@
+export enum HMSPollUserTrackingMode {
+  /**
+   User tracking is based on the peer ID.
+   */
+  peerID,
+
+  /**
+   User tracking is based on the customer ID.
+   */
+  customerUserID,
+
+  /**
+   User tracking is based on the username.
+   */
+  userName,
+}

package/src/hooks/polls.ts

@@ -0,0 +1,14 @@
+import type { HMSPoll } from '../classes/polls/HMSPoll';
+import { useHMSInteractivityStore } from '../stores/hms-interactivity-store';
+
+// use latest state (with component rerender)
+
+export const usePollsState = (pollId?: HMSPoll['pollId']) => {
+  return useHMSInteractivityStore((state) =>
+    pollId ? state.polls[pollId] : state.polls
+  );
+};
+
+// state setters
+
+export const setPollsState = useHMSInteractivityStore.getState().setPolls;

package/src/index.ts

@@ -95,6 +95,15 @@ export type {
 } from './classes/HmsView';
 export type { HMSPIPConfig } from './classes/HMSPIPConfig';
 export { HMSRecordingState } from './classes/HMSRecordingState';
+export type { HMSPoll } from './classes/polls/HMSPoll';
+
+export { HMSPollQuestionType } from './classes/polls/HMSPollQuestionType';
+export { HMSPollType } from './classes/polls/HMSPollType';
+export { HMSPollUserTrackingMode } from './classes/polls/HMSPollUserTrackingMode';
+export { HMSPollUpdateType } from './classes/polls/HMSPollUpdateType';
+export { HMSPollState } from './classes/polls/HMSPollState';
+export { HMSPollQuestion } from './classes/polls/HMSPollQuestion';
+export { HMSPollQuestionOption } from './classes/polls/HMSPollQuestionOption';
 
 import { HMSSDK as HmsManager } from './classes/HMSSDK';
 

package/src/stores/hms-interactivity-store.ts

@@ -0,0 +1,18 @@
+import { create } from 'zustand';
+import { subscribeWithSelector } from 'zustand/middleware';
+// import { immer } from 'zustand/middleware/immer';
+
+import { createHMSPollsSlice } from './hms-polls-slice';
+import type { HMSInteractivityStore } from './types';
+
+export const useHMSInteractivityStore = create<HMSInteractivityStore>()(
+  // [['zustand/subscribeWithSelector', never], ['zustand/immer', never]]
+  subscribeWithSelector(
+    // immer((...a) => ({
+    //   ...createHMSPollsSlice(...a),
+    // }))
+    (...a) => ({
+      ...createHMSPollsSlice(...a),
+    })
+  )
+);

package/src/stores/hms-polls-slice.ts

@@ -0,0 +1,20 @@
+import type { StateCreator } from 'zustand';
+import type { HMSInteractivityStore, HMSPollsSlice } from './types';
+import type { HMSPoll } from '../classes/polls/HMSPoll';
+
+export const createHMSPollsSlice: StateCreator<
+  HMSInteractivityStore,
+  [],
+  [],
+  HMSPollsSlice
+> = (set) => ({
+  polls: {},
+  setPolls: (poll: HMSPoll) => {
+    set((state) => {
+      state.polls[poll.pollId] = poll;
+      return state; // TODO: remove when use immer
+    });
+  },
+  // cue: undefined,
+  // setCue: (cue: HMSHLSPlayerPlaybackCue) => set({ cue }),
+});

package/src/stores/types.ts

@@ -1,5 +1,6 @@
 // Stores
 
+import type { HMSPoll } from '../classes/polls/HMSPoll';
 import type {
   HMSHLSPlayerPlaybackState,
   HMSHLSPlayerPlaybackCueEventData,
@@ -11,8 +12,9 @@ import type {
 
 export type HMSStore = HMSHLSPlayerPlaybackSlice & HMSViewsSlice;
 export type HMSHLSPlayerStatsStore = HMSHLSPlayerStatsSlice;
+export type HMSInteractivityStore = HMSPollsSlice;
 
-// HMSViews Slice
+//#region HMSViews Slice
 
 export type TrackId = string;
 
@@ -26,7 +28,9 @@ export interface HMSViewsSlice {
   setHmsviewsResolutions(trackId: TrackId, resolution: Resolution): void;
 }
 
-// HLS Player Playback Slice
+//#endregion HMSViews Slice
+
+//#region HLS Player Playback Slice
 
 export interface HMSHLSPlayerPlaybackCue
   extends Omit<HMSHLSPlayerPlaybackCueEventData, 'endDate' | 'startDate'> {
@@ -55,7 +59,9 @@ export interface HMSHLSPlayerPlaybackSlice {
   setPlaybackError(error: HMSHLSPlayerPlaybackError): void;
 }
 
-// HLS Player Stats Slice
+//#endregion HLS Player Playback Slice
+
+//#region HLS Player Stats Slice
 
 export type HMSHLSPlayerStats = HMSHLSPlayerStatsUpdateEventData;
 export type HMSHLSPlayerStatsError =
@@ -68,3 +74,14 @@ export interface HMSHLSPlayerStatsSlice {
   changeStats(stats: HMSHLSPlayerStats): void;
   setError(error: HMSHLSPlayerStatsError): void;
 }
+
+//#endregion HLS Player Stats Slice
+
+//#region Polls Slice
+
+export type HMSPollsSlice = {
+  polls: Record<string, HMSPoll>;
+  setPolls(poll: HMSPoll): void;
+};
+
+//#endregion Polls Slice

package/src/utils/emitter/EventEmitter.ts

@@ -20,6 +20,10 @@ export { EmitterSubscription } from './_EmitterSubscription';
  */
 export class EventEmitter {
   _subscriber: EventSubscriptionVendor;
+  _onAllListenersRemoved:
+    | ((eventType: string | 'all') => void)
+    | null
+    | undefined;
 
   /**
    * @constructor
@@ -31,6 +35,17 @@ export class EventEmitter {
     this._subscriber = subscriber || new EventSubscriptionVendor();
   }
 
+  /**
+   * Registers a listener to be invoked when all event listeners have been removed
+   * Given listener is invoked with event type or `all` when all listeners are removed
+   * @param onAllListenersRemoved
+   */
+  registerOnAllListenersRemoved(
+    onAllListenersRemoved: (eventType: string | 'all') => void
+  ) {
+    this._onAllListenersRemoved = onAllListenersRemoved;
+  }
+
   /**
    * Adds a listener to be invoked when events of the specified type are
    * emitted. An optional calling context may be provided. The data arguments
@@ -65,6 +80,7 @@ export class EventEmitter {
    */
   removeAllListeners(eventType: string | undefined | null) {
     this._subscriber.removeAllSubscriptions(eventType);
+    this._onAllListenersRemoved?.(eventType || 'all');
   }
 
   /**
@@ -77,7 +93,17 @@ export class EventEmitter {
       return;
     }
 
+    const eventType = subscription.eventType;
     this._subscriber.removeSubscription(subscription);
+
+    // check if all subscriptions are removed for the event type
+    if (
+      typeof this._onAllListenersRemoved === 'function' &&
+      this.listenerCount(eventType) === 0
+    ) {
+      // invoke passed cleanup function if any for the event type
+      this._onAllListenersRemoved(eventType);
+    }
   }
 
   /**