@fluidframework/react 0.41.4 → 2.62.0

package/src/helpers/rootCallbackListener.ts

@@ -1,104 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { ISharedMap, IValueChanged } from "@fluidframework/map";
-import { IFluidDataStoreRuntime } from "@fluidframework/datastore-definitions";
-import {
-    FluidObjectMap,
-    ViewToFluidMap,
-    FluidToViewMap,
-    IViewState,
-    IFluidState,
-} from "../interface";
-import { ISyncedState } from "..";
-import { syncState } from "./syncState";
-import { getByFluidKey } from "./utils";
-import { getViewFromFluid } from "./getViewFromFluid";
-import { getFluidState } from ".";
-
-/**
- * The callback that is added to the "valueChanged" event on the Fluid object this
- * is passed in to. This will trigger state updates when the synced state value is updated
- * @param fluidObjectMap - A map of Fluid handle paths to their Fluid objects
- * @param syncedStateId - Unique ID for this synced Fluid object's state
- * @param syncedState - The shared map this Fluid object's synced state is stored on
- * @param runtime - The data store runtime
- * @param state - The current view state
- * @param setState - Callback to update the react view state
- * @param fluidToView - A map of the Fluid state values that need conversion to their view state counterparts and the
- * respective converters
- * @param viewToFluid - A map of the view state values that need conversion to their Fluid state counterparts and the
- * respective converters
- */
-export const syncedStateCallbackListener = <
-    SV extends IViewState,
-    SF extends IFluidState
->(
-    fluidObjectMap: FluidObjectMap,
-    storedHandleMap: ISharedMap,
-    syncedStateId,
-    syncedState: ISyncedState,
-    runtime: IFluidDataStoreRuntime,
-    state: SV,
-    setState: (
-        newState: SV,
-        fromRootUpdate?: boolean,
-        isLocal?: boolean
-    ) => void,
-    fluidToView: FluidToViewMap<SV, SF>,
-    viewToFluid?: ViewToFluidMap<SV, SF>,
-) => (change: IValueChanged, local: boolean) => {
-    const currentFluidState = getFluidState(
-        syncedStateId,
-        syncedState,
-        fluidObjectMap,
-        fluidToView,
-    );
-    if (currentFluidState === undefined) {
-        throw Error("Synced state update triggered before Fluid state was initialized");
-    }
-    const viewToFluidKeys: string[] = viewToFluid !== undefined
-        ? Array.from(viewToFluid.values()).map((item) => item.fluidKey as string)
-        : [];
-    if (!local && change.key === `syncedState-${syncedStateId}`) {
-        // If the update is to the synced Fluid state, update both the Fluid and view states
-        syncState(
-            true,
-            syncedStateId,
-            syncedState,
-            runtime,
-            state,
-            setState,
-            fluidObjectMap,
-            fluidToView,
-            viewToFluid,
-        );
-    } else if (
-        viewToFluid !== undefined &&
-        viewToFluidKeys.includes(change.key)
-    ) {
-        // If the update is to a child Fluid object, trigger only a view update as the child itself will
-        // update its Fluid update
-        const stateKey = getByFluidKey(change.key, viewToFluid);
-        if (stateKey !== undefined) {
-            const newPartialState = getViewFromFluid(
-                syncedStateId,
-                syncedState,
-                change.key as keyof SF,
-                fluidObjectMap,
-                fluidToView,
-                state,
-                currentFluidState,
-            );
-            state[stateKey as string] = newPartialState[stateKey];
-            state.fluidObjectMap = fluidObjectMap;
-            setState(state, true, local);
-        } else {
-            throw Error(
-                `Unable to extract view state from synced state change key: ${change.key}`,
-            );
-        }
-    }
-};

package/src/helpers/setComponentSchema.ts

@@ -1,21 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { ISyncedState } from "..";
-import { IFluidSchemaHandles } from "./internalInterface";
-
-/**
- * Store the schema on to the shared synced state
- * @param syncedStateId - Unique ID to use for storing the synced state in the shared map
- * @param syncedState - The shared map that will be used to store the synced state
- * @param schemaHandles - Handles for the schema SharedMaps
- */
-export function setSchema(
-    syncedStateId: string,
-    syncedState: ISyncedState,
-    schemaHandles: IFluidSchemaHandles,
-): void {
-    syncedState.set(`schema-${syncedStateId}`, schemaHandles);
-}

package/src/helpers/setFluidState.ts

@@ -1,116 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { ISharedMap, SharedMap } from "@fluidframework/map";
-import { IFluidDataStoreRuntime } from "@fluidframework/datastore-definitions";
-import { IFluidHandle } from "@fluidframework/core-interfaces";
-import {
-    FluidObjectMap,
-    IViewConverter,
-    IFluidConverter,
-    ISyncedState,
-} from "../interface";
-
-/**
- * Store the Fluid state onto the shared synced state
- * @param syncedStateId - Unique ID to use for storing the Fluid object's synced state in the map
- * @param syncedState - The shared map that will be used to store the synced state
- * @param runtime - The data store runtime
- * @param fluidObjectMap - A map of Fluid handle paths to their Fluid objects
- * @param fluidToView - A map of the Fluid state values that need conversion to their view state counterparts and the
- * respective converters
- * @param newFluidState - The Fluid state to store on to the syncedState,
- * after converting Fluid objects to their handles
- */
-export function setFluidState<SV, SF>(
-    syncedStateId: string,
-    syncedState: ISyncedState,
-    runtime: IFluidDataStoreRuntime,
-    fluidObjectMap: FluidObjectMap,
-    fluidToView: Map<keyof SF, IViewConverter<SV, SF>>,
-    newViewState: SV,
-    newFluidState?: SF,
-    viewToFluid?: Map<keyof SV, IFluidConverter<SV, SF>>,
-): IFluidHandle {
-    const storedStateHandle = syncedState.get<IFluidHandle>(
-        `syncedState-${syncedStateId}`,
-    );
-    let storedState: ISharedMap | undefined;
-    if (storedStateHandle) {
-        storedState = fluidObjectMap.get(storedStateHandle.absolutePath)
-            ?.fluidObject as ISharedMap;
-    }
-    if (storedStateHandle === undefined || storedState === undefined) {
-        const newState = SharedMap.create(runtime);
-        fluidObjectMap.set(newState.handle.absolutePath, {
-            fluidObject: newState,
-            isRuntimeMap: true,
-        });
-        storedState = newState;
-    }
-    if (storedState === undefined) {
-        throw Error("Failed to fetch synced state from root");
-    }
-    for (const key of fluidToView.keys()) {
-        const fluidKey = key as string;
-        const syncedStateKey = fluidToView?.get(fluidKey as keyof SF)?.rootKey;
-        const createCallback = fluidToView?.get(fluidKey as keyof SF)
-            ?.sharedObjectCreate;
-        if (createCallback !== undefined) {
-            if (storedState.get(fluidKey) === undefined) {
-                const sharedObject = createCallback(runtime);
-                fluidObjectMap.set(sharedObject.handle.absolutePath, {
-                    fluidObject: sharedObject,
-                    listenedEvents: fluidToView?.get(fluidKey as keyof SF)
-                        ?.listenedEvents ?? ["valueChanged"],
-                });
-                storedState.set(fluidKey, sharedObject.handle);
-                if (syncedStateKey !== undefined) {
-                    syncedState.set(syncedStateKey, sharedObject.handle);
-                }
-            } else {
-                storedState.set(fluidKey, storedState.get(fluidKey));
-                if (syncedStateKey !== undefined) {
-                    syncedState.set(
-                        syncedStateKey,
-                        syncedState.get(syncedStateKey),
-                    );
-                }
-            }
-        } else if (syncedStateKey !== undefined) {
-            const value = newFluidState !== undefined
-                ? newFluidState[fluidKey]
-                : syncedState.get(syncedStateKey);
-            syncedState.set(syncedStateKey, value);
-            storedState.set(fluidKey, value);
-        } else {
-            const value = newFluidState !== undefined
-                ? newFluidState[fluidKey]
-                : storedState.get(fluidKey);
-            storedState.set(fluidKey, value);
-        }
-    }
-    if (viewToFluid !== undefined && newFluidState !== undefined) {
-        for (const key of viewToFluid.keys()) {
-            const viewKey = key as string;
-            const fluidConverter = viewToFluid?.get(viewKey as keyof SV)
-                ?.fluidConverter;
-            const fluidKey = viewToFluid?.get(viewKey as keyof SV)
-                ?.fluidKey;
-            if (fluidConverter !== undefined && fluidKey !== undefined) {
-                const value = fluidConverter(newViewState, newFluidState);
-                // Write this value to the stored state if it doesn't match the name of a view value
-                if (
-                    fluidToView.get(fluidKey)?.sharedObjectCreate ===
-                    undefined
-                ) {
-                    storedState.set(viewKey, value);
-                }
-            }
-        }
-    }
-    syncedState.set(`syncedState-${syncedStateId}`, storedState.handle);
-    return storedState.handle;
-}

package/src/helpers/syncState.ts

@@ -1,159 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { IFluidDataStoreRuntime } from "@fluidframework/datastore-definitions";
-import { ISharedMap } from "@fluidframework/map";
-import {
-    FluidObjectMap,
-    IFluidState,
-    IViewState,
-    ViewToFluidMap,
-    FluidToViewMap,
-    ISyncedState,
-} from "../interface";
-import { getFluidFromView } from "./getFluidFromView";
-import { getViewFromFluid } from "./getViewFromFluid";
-import { getFluidState } from "./getFluidState";
-import { setFluidState } from "./setFluidState";
-import { getSchema } from "./getSchema";
-
-/**
- * Function to combine both the view and Fluid states so that they are in sync. If the update
- * is from a local update, the new Fluid state created from converting the new local view state
- * is used to update the synced Fluid state, which in turn will update the local state on other clients.
- * If it is an update triggered from a remote change on the synced state, the new Fluid state from the synced state
- * is used to overwrite the local synced state and the new local view is created accordingly.
- * @param isSyncedStateUpdate - Is the update from a local state update or from one triggered by the synced state
- * @param syncedStateId - Unique ID for this synced Fluid object's state
- * @param syncedState - The shared map this Fluid object synced state is stored on
- * @param viewState - The current view state
- * @param setState - Callback to update the react view state
- * @param fluidObjectMap - A map of Fluid handle paths to their Fluid objects
- * @param viewToFluid - A map of the view state values that need conversion to their Fluid state counterparts and the
- * respective converters
- * @param fluidToView - A map of the Fluid state values that need conversion to their view state counterparts and the
- * respective converters
- */
-export function syncState<
-    SV extends IViewState,
-    SF extends IFluidState
->(
-    isSyncedStateUpdate: boolean,
-    syncedStateId: string,
-    syncedState: ISyncedState,
-    runtime: IFluidDataStoreRuntime,
-    viewState: SV,
-    setState: (
-        newState: SV,
-        isSyncedStateUpdate?: boolean,
-        isLocal?: boolean
-    ) => void,
-    fluidObjectMap: FluidObjectMap,
-    fluidToView: FluidToViewMap<SV, SF>,
-    viewToFluid?: ViewToFluidMap<SV, SF>,
-) {
-    // Use the provided Fluid state if it is available, or use the one fetched from the synced state
-    const currentFluidState = getFluidState(
-        syncedStateId,
-        syncedState,
-        fluidObjectMap,
-        fluidToView,
-    );
-    if (currentFluidState === undefined) {
-        throw Error(
-            "Attempted to sync view and Fluid states before Fluid state was initialized",
-        );
-    }
-    // Fetch the schema
-    const schemaHandles = getSchema(
-        syncedStateId,
-        syncedState,
-    );
-    if (schemaHandles === undefined) {
-        throw Error("No schema found stored on the root");
-    }
-    const {
-        viewMatchingMapHandle,
-        fluidMatchingMapHandle,
-    } = schemaHandles;
-
-    const viewMatchingMap = fluidObjectMap.get(viewMatchingMapHandle.absolutePath)
-        ?.fluidObject as ISharedMap;
-    const fluidMatchingMap = fluidObjectMap.get(fluidMatchingMapHandle.absolutePath)
-        ?.fluidObject as ISharedMap;
-
-    if (viewMatchingMap === undefined || fluidMatchingMap === undefined) {
-        throw Error("Failed to fetch shared map DDSes from the schema handles");
-    }
-
-    // Create the combined root state by combining the current root state and the new
-    // view state after it has been converted
-    let combinedFluidState = { ...currentFluidState };
-    Object.entries(viewState).forEach(([viewKey, viewValue]) => {
-        const needsConverter = viewMatchingMap.get(viewKey);
-        let partialRootState = {};
-        if (needsConverter !== undefined) {
-            partialRootState = getFluidFromView(
-                viewState,
-                viewKey as keyof SV,
-                currentFluidState,
-                viewToFluid,
-            );
-        } else {
-            partialRootState[viewKey] = viewState[viewKey];
-        }
-        // If it is from a synced state update, the values fetched from the synced state at the beginning
-        // overwrite those created here. Otherwise, the new values overwrite those in the synced state
-        if (isSyncedStateUpdate) {
-            combinedFluidState = { ...partialRootState, ...combinedFluidState };
-        } else {
-            combinedFluidState = { ...combinedFluidState, ...partialRootState };
-        }
-    });
-
-    // Create the combined view state by combining the current view with the new Fluid state
-    // after it has been converted
-    let combinedViewState = { ...viewState, ...{ fluidObjectMap } };
-    Object.entries(currentFluidState).forEach(([fluidKey, fluidValue]) => {
-        const needsConverter = fluidMatchingMap.get(fluidKey);
-        let partialViewState = {};
-        if (needsConverter !== undefined) {
-            partialViewState = getViewFromFluid(
-                syncedStateId,
-                syncedState,
-                fluidKey as keyof SF,
-                fluidObjectMap,
-                fluidToView,
-                combinedViewState,
-                combinedFluidState,
-            );
-        } else {
-            partialViewState[fluidKey] = currentFluidState[fluidKey];
-        }
-        // If it is from a synced state update, the values converted from the synced state overwrite those
-        // created here. Otherwise, the new view values overwrite those from the synced state.
-        if (isSyncedStateUpdate) {
-            combinedViewState = { ...combinedViewState, ...partialViewState };
-        } else {
-            combinedViewState = { ...partialViewState, ...combinedViewState };
-        }
-    });
-
-    // If it is a local update, broadcast it by setting it on the root and updating locally
-    // Otherwise, only update locally as the root update has already been broadcasted
-    if (!isSyncedStateUpdate) {
-        setFluidState(
-            syncedStateId,
-            syncedState,
-            runtime,
-            fluidObjectMap,
-            fluidToView,
-            combinedViewState,
-            combinedFluidState,
-            viewToFluid,
-        );
-    }
-    setState(combinedViewState, isSyncedStateUpdate, true);
-}

package/src/helpers/updateStateAndFluidObjectMap.ts

@@ -1,85 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { IDirectoryValueChanged, SharedMap } from "@fluidframework/map";
-import { IFluidHandle } from "@fluidframework/core-interfaces";
-import { IFluidDataStoreRuntime } from "@fluidframework/datastore-definitions";
-import {
-    FluidObjectMap,
-    IFluidState,
-    IViewState,
-    ViewToFluidMap,
-    FluidToViewMap,
-} from "../interface";
-import { ISyncedState } from "..";
-import { addFluidObject, asyncForEach } from "./utils";
-import { syncState } from "./syncState";
-
-/**
- * Add listeners too all the new handles passed in, store their respective Fluid objects
- * on the fluidObjectMap, and then update both the local and synced state
- * @param newHandleList - List of IFluidHandles for new Fluid objects that need to be added to the map
- * @param fluidObjectMap - A map of Fluid handle paths to their Fluid objects
- * @param isSyncedStateUpdate - Is the update from a local state update or from one triggered by the synced state
- * @param syncedStateId - Unique ID for this synced Fluid object's state
- * @param syncedState - The shared map this Fluid object's synced state is stored on
- * @param runtime - The data store runtime
- * @param viewState - The current view state
- * @param setState - Callback to update the react view state
- * @param syncedStateCallback - The callback that will be triggered when the synced state value for the Fluid objects
- * passed in changes
- * @param fluidToView - A map of the Fluid state values that need conversion to their view state counterparts and the
- * respective converters
- * @param viewToFluid - A map of the view state values that need conversion to their Fluid state counterparts and the
- * respective converters
- */
-export const updateStateAndFluidObjectMap = async <
-    SV extends IViewState,
-    SF extends IFluidState
->(
-    newHandleList: IFluidHandle[],
-    fluidObjectMap: FluidObjectMap,
-    storedHandleMap: SharedMap,
-    isSyncedStateUpdate: boolean,
-    syncedStateId: string,
-    syncedState: ISyncedState,
-    runtime: IFluidDataStoreRuntime,
-    viewState: SV,
-    setState: (newState: SV, isSyncedStateUpdate?: boolean) => void,
-    syncedStateCallback: (change: IDirectoryValueChanged, local: boolean) => void,
-    fluidToView: FluidToViewMap<SV, SF>,
-    viewToFluid?: ViewToFluidMap<SV, SF>,
-) =>
-    asyncForEach(
-        newHandleList,
-        addFluidObject,
-        fluidObjectMap,
-        syncedStateCallback,
-        () =>
-            syncState(
-                true,
-                syncedStateId,
-                syncedState,
-                runtime,
-                viewState,
-                setState,
-                fluidObjectMap,
-                fluidToView,
-                viewToFluid,
-            ),
-        storedHandleMap,
-    ).then(() =>
-        syncState(
-            isSyncedStateUpdate,
-            syncedStateId,
-            syncedState,
-            runtime,
-            viewState,
-            setState,
-            fluidObjectMap,
-            fluidToView,
-            viewToFluid,
-        ),
-    );

package/src/helpers/utils.tsx

@@ -1,109 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { IFluidHandle } from "@fluidframework/core-interfaces";
-import { IDirectoryValueChanged, SharedMap } from "@fluidframework/map";
-import { SharedObject } from "@fluidframework/shared-object-base";
-import {
-    FluidObjectMap,
-    IFluidState,
-    IViewState,
-    IFluidConverter,
-} from "../interface";
-import { IFluidObjectMapItem } from "..";
-
-export function getByFluidKey<
-    SV extends IViewState,
-    SF extends IFluidState
->(searchValue: string, map: Map<keyof SV, IFluidConverter<SV, SF>>) {
-    for (const [key, value] of map.entries()) {
-        if (value.fluidKey === searchValue) {
-            return key;
-        }
-    }
-}
-
-export async function asyncForEach(
-    array: IFluidHandle[],
-    callback: (
-        handle: IFluidHandle,
-        fluidObjectMap: FluidObjectMap,
-        syncedStateCallback: (change: IDirectoryValueChanged, local: boolean) => void,
-        refreshView: () => void,
-        storedHandleMap: SharedMap,
-    ) => Promise<void>,
-    fluidObjectMap: FluidObjectMap,
-    syncedStateCallback: (change: IDirectoryValueChanged, local: boolean) => void,
-    refreshView: () => void,
-    storedHandleMap: SharedMap,
-): Promise<void> {
-    const promises: Promise<void>[] = [];
-    for (const value of array) {
-        promises.push(
-            callback(value, fluidObjectMap, syncedStateCallback, refreshView, storedHandleMap),
-        );
-    }
-    await Promise.all(promises);
-}
-
-export const addFluidObject = async <
-    SV extends IViewState,
-    SF extends IFluidState
->(
-    handle: IFluidHandle,
-    fluidObjectMap: FluidObjectMap,
-    syncedStateCallback: (change: IDirectoryValueChanged, local: boolean) => void,
-    refreshView: () => void,
-    storedHandleMap: SharedMap,
-): Promise<void> => {
-    const maybeValue: IFluidObjectMapItem | undefined = fluidObjectMap.get(handle.absolutePath);
-    let value: IFluidObjectMapItem = {
-        isListened: false,
-        isRuntimeMap: false,
-    };
-    if (maybeValue === undefined) {
-        fluidObjectMap.set(
-            handle.absolutePath,
-            value,
-        );
-    } else {
-        value = maybeValue;
-    }
-    value.isListened = false;
-    fluidObjectMap.set(handle.absolutePath, value);
-    if (!storedHandleMap.has(handle.absolutePath)) {
-        storedHandleMap.set(handle.absolutePath, handle);
-    }
-    return handle.get().then((fluidObject) => {
-        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-        if (value.isRuntimeMap) {
-            (fluidObject as SharedMap).on("valueChanged", syncedStateCallback);
-        } else if (value.listenedEvents !== undefined) {
-            for (const event of value.listenedEvents) {
-                (fluidObject as SharedObject).on(event, refreshView);
-            }
-        }
-        value.fluidObject = fluidObject;
-        value.isListened = true;
-        fluidObjectMap.set(handle.absolutePath, value);
-    });
-};
-
-export function isEquivalent(a, b) {
-    if (a === undefined || b === undefined) {
-        return a === b;
-    }
-    const aKeys = Object.getOwnPropertyNames(a);
-    const bKeys = Object.getOwnPropertyNames(b);
-    if (aKeys.length !== bKeys.length) {
-        return false;
-    }
-    for (const i of aKeys) {
-        if (a[i] !== b[i]) {
-            return false;
-        }
-    }
-    return true;
-}