@microsoft/live-share-react 2.0.0-internal.1 → 2.0.0-internal.11

package/src/live-hooks/useLivePresence.ts

@@ -5,20 +5,24 @@
 
 import {
     LivePresenceUser,
-    PresenceState,
     LivePresence,
     UserMeetingRole,
     LiveDataObjectInitializeState,
+    LivePresenceData,
+    PresenceStatus,
 } from "@microsoft/live-share";
 import React from "react";
-import { IUseLivePresenceResults, OnUpdateLivePresenceAction } from "../types";
-import { useDynamicDDS } from "../shared-hooks";
-import { useFluidObjectsContext } from "../providers";
+import {
+    IUseLivePresenceResults,
+    OnUpdateLivePresenceAction,
+} from "../types/index.js";
+import { useDynamicDDS } from "../shared-hooks/index.js";
+import { useFluidObjectsContext } from "../providers/index.js";
 import {
     ActionContainerNotJoinedError,
     ActionLiveDataObjectInitializedError,
     ActionLiveDataObjectUndefinedError,
-} from "../internal";
+} from "../internal/index.js";
 
 /**
  * React hook for using a Live Share `LivePresence`.
@@ -31,17 +35,66 @@ import {
  *
  * @template TData Optional typing for the custom user presence data object. Default is `object` type.
  * @param uniqueKey The unique key for `LivePresence`. If one does not yet exist, a new one will be created.
- * @param initialData Optional. Initial presence data object for the user. Can be value or a function to get the value.
- * @param initialPresenceState Optional. Initial status of the user's presence. Default is online.
+ * @param initialData Initial presence data object for the user. Can be value or a function to get the value.
  * @param allowedRoles Optional. the user roles that are allowed to mutate the synchronized state
  * will be created, otherwise it will use the existing one. Default value is ":<dds-default>"
  * @returns stateful `localUser`, `otherUsers` list, and `allUsers` list. Also returns a callback method
  * to update the local user's presence and the `LivePresence` Fluid object.
+ * 
+ * @example
+ ```jsx
+import { useLivePresence } from "@microsoft/live-share-react";
+
+// Define a unique key that differentiates this usage of `useLivePresence` from others in your app
+const MY_UNIQUE_KEY = "presence-key";
+
+// Example component for using useLivePresence
+export const MyCustomPresence = () => {
+    const {
+        allUsers,
+        localUser,
+        livePresence,
+        updatePresence,
+    } = useLivePresence(MY_UNIQUE_KEY, {
+        picture: "DEFAULT_PROFILE_PICTURE_URL",
+        readyToStart: false,
+    });
+
+    // Callback to update the user's presence
+    const onToggleReady = () => {
+        updatePresence({
+            ...localUser.data,
+            readyToStart: !localUser.data.readyToStart,
+        });
+    }
+
+    // Render loading UI while loading LivePresence for first time
+    if (!livePresence) return <>Loading...</>;
+
+    // Render presence UI
+    return (
+        {allUsers.map((user) => (
+            <div key={user.userId}>
+                <div>
+                    {user.displayName}
+                </div>
+                <div>
+                    {`Ready: ${user.data.readyToStart}`}
+                </div>
+                {user.isLocalUser && (
+                    <button onClick={onToggleReady}>
+                        {"Toggle ready"}
+                    </button>
+                )}
+            </div>
+        ))}
+    );
+}
+ ```
  */
-export function useLivePresence<TData extends object = object>(
+export function useLivePresence<TData extends LivePresenceData = any>(
     uniqueKey: string,
-    initialData?: TData | (() => TData) | undefined,
-    initialPresenceState: PresenceState = PresenceState.online,
+    initialData: TData | (() => TData),
     allowedRoles?: UserMeetingRole[]
 ): IUseLivePresenceResults<TData> {
     /**
@@ -55,18 +108,26 @@ export function useLivePresence<TData extends object = object>(
      */
     const { dds: livePresence } = useDynamicDDS<LivePresence<TData>>(
         uniqueKey,
-        LivePresence<TData>
+        LivePresence
     );
 
     /**
      * User facing: list of non-local user's presence objects.
      */
-    const otherUsers = allUsers.filter((user) => !user.isLocalUser);
+    const otherUsers = React.useMemo(() => {
+        return allUsers.filter((user) => !user.isLocalUser);
+    }, [allUsers]);
 
     /**
      * User facing: local user's presence object.
      */
-    const localUser = allUsers.find((user) => user.isLocalUser);
+    const localUser = React.useMemo(() => {
+        return allUsers.find((user) => user.isLocalUser);
+    }, [allUsers]);
+
+    const onlineUsers = React.useMemo(() => {
+        return allUsers.filter((user) => user.status === PresenceStatus.online);
+    }, [allUsers]);
 
     const { container } = useFluidObjectsContext();
 
@@ -74,7 +135,7 @@ export function useLivePresence<TData extends object = object>(
      * User facing: callback to update the local user's presence.
      */
     const updatePresence: OnUpdateLivePresenceAction<TData> = React.useCallback(
-        async (data?: TData | undefined, state?: PresenceState | undefined) => {
+        async (data: TData) => {
             if (!container) {
                 throw new ActionContainerNotJoinedError(
                     "livePresence",
@@ -93,7 +154,7 @@ export function useLivePresence<TData extends object = object>(
                     "updatePresence"
                 );
             }
-            return await livePresence.update(data, state);
+            return await livePresence.update(data);
         },
         [container, livePresence]
     );
@@ -121,7 +182,6 @@ export function useLivePresence<TData extends object = object>(
                 isInitialDataCallback<TData>(initialData)
                     ? initialData()
                     : initialData,
-                initialPresenceState,
                 allowedRoles
             );
         }
@@ -136,11 +196,14 @@ export function useLivePresence<TData extends object = object>(
         localUser,
         otherUsers,
         allUsers,
+        onlineUsers,
         livePresence,
         updatePresence,
     };
 }
 
-function isInitialDataCallback<TData>(value: any): value is () => TData {
+function isInitialDataCallback<TData extends LivePresenceData>(
+    value: any
+): value is () => TData {
     return typeof value === "function";
 }

package/src/live-hooks/useLiveState.ts

@@ -9,15 +9,15 @@ import {
     UserMeetingRole,
 } from "@microsoft/live-share";
 import React from "react";
-import { SetLiveStateAction } from "../types";
-import { useDynamicDDS } from "../shared-hooks";
-import { useFluidObjectsContext } from "../providers";
+import { SetLiveStateAction } from "../types/index.js";
+import { useDynamicDDS } from "../shared-hooks/index.js";
+import { useFluidObjectsContext } from "../providers/index.js";
 import {
     ActionContainerNotJoinedError,
     ActionLiveDataObjectInitializedError,
     ActionLiveDataObjectUndefinedError,
     isPrevStateCallback,
-} from "../internal";
+} from "../internal/index.js";
 
 /**
  * React hook for using a Live Share `LiveState`.
@@ -31,6 +31,51 @@ import {
  * @param allowedRoles Optional. the user roles that are allowed to mutate the synchronized state
  * @returns ordered values: first value is the synchronized state value and the second is a setter to change the state value.
  * The setter returns a void promise, which will throw if the user does not have the required roles to set.
+ * 
+ * @example
+ ```jsx
+import { useLiveState } from "@microsoft/live-share-react";
+
+const planets = [
+  "Mercury",
+  "Venus",
+  "Earth",
+  "Mars",
+  "Jupiter",
+  "Saturn",
+  "Uranus",
+  "Neptune",
+];
+
+// Define a unique key that differentiates this usage of `useLiveState` from others in your app
+const MY_UNIQUE_KEY = "selected-planet-key";
+
+// Example component for using useLiveState
+export const MyCustomState = () => {
+  const [planet, setPlanet, liveState] = useLiveState(MY_UNIQUE_KEY, planets[0]);
+
+  // Render loading UI when creating LiveState instance for first time
+  if (!liveState) return <>Loading...</>;
+
+  // Render UI
+  return (
+    <div>
+      {`Current planet: ${planet}`}
+      {"Select a planet below:"}
+      {planets.map((planet) => (
+        <button
+          key={planet}
+          onClick={() => {
+            setPlanet(planet);
+          }}
+        >
+          {planet}
+        </button>
+      ))}
+    </div>
+  );
+};
+ ```
  */
 export function useLiveState<TState = any>(
     uniqueKey: string,
@@ -95,9 +140,12 @@ export function useLiveState<TState = any>(
         if (
             liveState.initializeState === LiveDataObjectInitializeState.needed
         ) {
-            liveState.initialize(initialState, allowedRoles);
+            liveState
+                .initialize(initialState, allowedRoles)
+                .then(() => onStateChanged(liveState.state));
+        } else {
+            onStateChanged(liveState.state);
         }
-        onStateChanged(liveState.state);
 
         return () => {
             liveState?.off("stateChanged", onStateChanged);

package/src/live-hooks/useLiveTimer.ts

@@ -21,14 +21,14 @@ import {
     OnTimerDidPlayAction,
     OnTimerDidStartAction,
     OnTimerTickAction,
-} from "../types";
-import { useDynamicDDS } from "../shared-hooks";
-import { useFluidObjectsContext } from "../providers";
+} from "../types/index.js";
+import { useDynamicDDS } from "../shared-hooks/index.js";
+import { useFluidObjectsContext } from "../providers/index.js";
 import {
     ActionContainerNotJoinedError,
     ActionLiveDataObjectInitializedError,
     ActionLiveDataObjectUndefinedError,
-} from "../internal";
+} from "../internal/index.js";
 
 /**
  * React hook for using Live Share's `LiveTimer` DDS.
@@ -46,6 +46,61 @@ import {
  * @param onPlay Optional. event handler callback for when the timer is resumed.
  * @param onFinish Optional. event handler callback for when the timer finishes.
  * @returns results and callbacks exposed via the hook.
+ * 
+ * @example
+ ```jsx
+import { useLiveTimer } from "@microsoft/live-share-react";
+
+// Define a unique key that differentiates this usage of `useLiveTimer` from others in your app
+const MY_UNIQUE_KEY = "timer-key";
+
+// Example component for using useLiveTimer
+export function CountdownTimer() {
+    const {
+        milliRemaining,
+        timerConfig,
+        liveTimer,
+        start,
+        pause,
+        play,
+    } = useLiveTimer("TIMER-ID");
+
+    // Render loading UI when creating LiveTimer instance for first time
+    if (!liveTimer) return <>Loading...</>;
+
+    return (
+        <div>
+            <button
+                onClick={() => {
+                    start(60 * 1000);
+                }}
+            >
+                {timerConfig === undefined ? "Start" : "Reset"}
+            </button>
+            {timerConfig !== undefined && (
+                <button
+                    onClick={() => {
+                        if (timerConfig.running) {
+                            pause();
+                        } else {
+                            play();
+                        }
+                    }}
+                >
+                    {timerConfig.running ? "Pause" : "Play"}
+                </button>
+            )}
+            {milliRemaining !== undefined && (
+                <p>
+                {`${Math.round(milliRemaining / 1000)} / ${
+                    Math.round(timerConfig.duration) / 1000
+                }`}
+                </p>
+            )}
+        </div>
+    );
+}
+ ```
  */
 export function useLiveTimer(
     uniqueKey: string,

package/src/live-hooks/useMediaSynchronizer.ts

@@ -16,14 +16,18 @@ import {
     MediaPlayerSynchronizer,
     MediaSessionCoordinatorSuspension,
 } from "@microsoft/live-share-media";
-import { isExtendedMediaMetadata, isMediaElement, isRefObject } from "../utils";
-import { useDynamicDDS } from "../shared-hooks";
-import { IUseMediaSynchronizerResults } from "../types";
-import { useFluidObjectsContext } from "../providers";
+import {
+    isExtendedMediaMetadata,
+    isMediaElement,
+    isRefObject,
+} from "../utils/index.js";
+import { useDynamicDDS } from "../shared-hooks/index.js";
+import { IUseMediaSynchronizerResults } from "../types/index.js";
+import { useFluidObjectsContext } from "../providers/index.js";
 import {
     ActionContainerNotJoinedError,
     ActionLiveDataObjectUndefinedError,
-} from "../internal";
+} from "../internal/index.js";
 
 /**
  * React hook for using a Live Share media `MediaPlayerSynchronizer`.
@@ -39,6 +43,67 @@ import {
  * @param viewOnly Optional. Flag for whether or not the media synchronizer should be in viewOnly mode.
  * @param canSendPositionUpdates Optional. Controls whether or not the local client is allowed to send position updates to the group.
  * @returns IUseMediaSynchronizerResults object.
+ * 
+ * @example
+ ```jsx
+import { useMediaSynchronizer } from "@microsoft/live-share-react";
+import { UserMeetingRole } from "@microsoft/live-share";
+import { MediaPlayerSynchronizerEvents } from "@microsoft/live-share-media";
+import { useRef, useEffect } from "react";
+
+const ALLOWED_ROLES = [UserMeetingRole.organizer, UserMeetingRole.presenter];
+
+const INITIAL_TRACK = "<YOUR_VIDEO_URL>";
+
+// Define a unique key that distinguishes this `useMediaSynchronizer` from others in your app
+const UNIQUE_KEY = "MEDIA-SESSION-ID";
+
+export function VideoPlayer() {
+  const videoRef = useRef(null);
+  const { play, pause, seekTo, mediaSynchronizer } = useMediaSynchronizer(
+    UNIQUE_KEY,
+    videoRef,
+    INITIAL_TRACK,
+    ALLOWED_ROLES
+  );
+
+  // Listen for groupaction events (optional)
+  useEffect(() => {
+    // Listen for player group actions for errors (e.g., play error)
+    const onGroupAction = (evt: IMediaPlayerSynchronizerEvent) => {
+      // See which user made the change (e.g., to display a notification)
+      const clientInfo = await synchronizer.mediaSession.getClientInfo(evt.details.clientId);
+    };
+    mediaSynchronizer?.addEventListener(
+      MediaPlayerSynchronizerEvents.groupaction,
+      onGroupAction
+    );
+    return () => {
+      mediaSynchronizer?.removeEventListener(
+        MediaPlayerSynchronizerEvents.groupaction,
+        onGroupAction
+      );
+    };
+  }, [mediaSynchronizer]);
+
+  return (
+    <div>
+      <video ref={videoRef} />
+      <button onClick={play}>
+        Play
+      </button>
+      <button onClick={pause}>
+        Pause
+      </button>
+      <button onClick={() => {
+        seekTo(0);
+      }}>
+        Start over
+      </button>
+    </div>
+  );
+}
+ ```
  */
 export function useMediaSynchronizer(
     uniqueKey: string,
@@ -250,7 +315,7 @@ export function useMediaSynchronizer(
             synchronizer.removeAllListeners();
             mediaSession.removeAllListeners();
             synchronizer?.end();
-            // mediaSession?.dispose();
+            mediaSession?.dispose();
         };
     }, [mediaSession, mediaPlayerElement]);
 

package/src/providers/AzureProvider.tsx

@@ -3,21 +3,19 @@
  * Licensed under the Microsoft Live Share SDK License.
  */
 
-import { IFluidContainer, LoadableObjectClassRecord } from "fluid-framework";
+import { ContainerSchema, IFluidContainer } from "fluid-framework";
 import React from "react";
 import {
     AzureClientProps,
     AzureContainerServices,
 } from "@fluidframework/azure-client";
-import { IAzureContainerResults } from "../types";
+import { IAzureContainerResults } from "../types/index.js";
 import {
     ISharedStateRegistryResponse,
     useSharedStateRegistry,
-} from "../shared-hooks";
-import {
-    AzureTurboClient,
-    IFluidTurboClient,
-} from "@microsoft/live-share-turbo";
+} from "../shared-hooks/index.js";
+import { AzureLiveShareClient } from "@microsoft/live-share";
+import { BaseLiveShareClient } from "@microsoft/live-share/internal";
 
 /**
  * React Context provider values for `<AzureProvider>` and `<LiveShareProvider>`.
@@ -29,7 +27,7 @@ export interface IFluidContext extends ISharedStateRegistryResponse {
     /**
      * The Fluid Turbo client used for connecting to the Fluid container.
      */
-    clientRef: React.MutableRefObject<IFluidTurboClient>;
+    clientRef: React.MutableRefObject<BaseLiveShareClient>;
     /**
      * Stateful Fluid container.
      */
@@ -54,7 +52,7 @@ export interface IFluidContext extends ISharedStateRegistryResponse {
      */
     getContainer: (
         containerId: string,
-        initialObjects?: LoadableObjectClassRecord
+        fluidContainerSchema?: ContainerSchema
     ) => Promise<IAzureContainerResults>;
     /**
      * React callback function to create and connect to a new Fluid container.
@@ -67,7 +65,7 @@ export interface IFluidContext extends ISharedStateRegistryResponse {
      * @returns promise that returns a results object once complete (e.g., container, services, etc.)
      */
     createContainer: (
-        initialObjects?: LoadableObjectClassRecord,
+        fluidContainerSchema?: ContainerSchema,
         onInitializeContainer?: (container: IFluidContainer) => void
     ) => Promise<IAzureContainerResults>;
 }
@@ -125,9 +123,9 @@ export interface IAzureProviderProps {
      */
     createOnLoad?: boolean;
     /**
-     * The initial object schema to use when {@link joinOnLoad} or {@link createOnLoad} is true.
+     * The initial schema to use when {@link joinOnLoad} or {@link createOnLoad} is true.
      */
-    initialObjects?: LoadableObjectClassRecord;
+    fluidContainerSchema?: ContainerSchema;
     /**
      * Flag to control whether or not to connect to an existing container on first mount.
      *
@@ -142,8 +140,8 @@ export interface IAzureProviderProps {
  */
 export const AzureProvider: React.FC<IAzureProviderProps> = (props) => {
     const startedRef = React.useRef<boolean>(false);
-    const clientRef = React.useRef<AzureTurboClient>(
-        new AzureTurboClient(props.clientOptions)
+    const clientRef = React.useRef<AzureLiveShareClient>(
+        new AzureLiveShareClient(props.clientOptions)
     );
     const [results, setResults] = React.useState<
         IAzureContainerResults | undefined
@@ -158,14 +156,14 @@ export const AzureProvider: React.FC<IAzureProviderProps> = (props) => {
     const getContainer = React.useCallback(
         async (
             containerId: string,
-            initialObjects?: LoadableObjectClassRecord
+            fluidContainerSchema?: ContainerSchema
         ): Promise<IAzureContainerResults> => {
             return new Promise(async (resolve, reject) => {
                 try {
                     const results: IAzureContainerResults =
                         await clientRef.current.getContainer(
                             containerId,
-                            initialObjects
+                            fluidContainerSchema
                         );
                     setResults(results);
                     resolve(results);
@@ -185,13 +183,15 @@ export const AzureProvider: React.FC<IAzureProviderProps> = (props) => {
      */
     const createContainer = React.useCallback(
         async (
-            initialObjects?: LoadableObjectClassRecord,
+            fluidContainerSchema?: ContainerSchema,
             onInitializeContainer?: (container: IFluidContainer) => void
         ): Promise<IAzureContainerResults> => {
             return new Promise(async (resolve, reject) => {
                 try {
                     const results: IAzureContainerResults =
-                        await clientRef.current.createContainer(initialObjects);
+                        await clientRef.current.createContainer(
+                            fluidContainerSchema
+                        );
                     if (onInitializeContainer) {
                         onInitializeContainer(results.container);
                     }
@@ -225,16 +225,16 @@ export const AzureProvider: React.FC<IAzureProviderProps> = (props) => {
             return;
         startedRef.current = true;
         if (props.containerId && props.joinOnLoad) {
-            getContainer(props.containerId, props.initialObjects);
+            getContainer(props.containerId, props.fluidContainerSchema);
         } else if (!props.containerId && props.createOnLoad) {
-            createContainer(props.initialObjects);
+            createContainer(props.fluidContainerSchema);
         }
     }, [
         results?.container?.connectionState,
         props.containerId,
         props.createOnLoad,
         props.joinOnLoad,
-        props.initialObjects,
+        props.fluidContainerSchema,
         getContainer,
         createContainer,
     ]);