@fluidframework/fluid-static 2.0.0-dev.1.4.6.106135 → 2.0.0-dev.2.2.0.111723

package/prettier.config.cjs

@@ -0,0 +1,8 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+module.exports = {
+    ...require("@fluidframework/build-common/prettier.config.cjs"),
+};

package/src/fluidContainer.ts

@@ -5,71 +5,74 @@
 import { TypedEventEmitter } from "@fluidframework/common-utils";
 import { IFluidLoadable } from "@fluidframework/core-interfaces";
 import { IEvent, IEventProvider } from "@fluidframework/common-definitions";
-import { AttachState, IContainer, ConnectionState } from "@fluidframework/container-definitions";
-import { LoadableObjectClass, LoadableObjectRecord } from "./types";
-import { RootDataObject } from "./rootDataObject";
+import {
+    AttachState,
+    IContainer,
+    ICriticalContainerError,
+    ConnectionState,
+} from "@fluidframework/container-definitions";
+import type { IRootDataObject, LoadableObjectClass, LoadableObjectRecord } from "./types";
 
 /**
  * Events emitted from {@link IFluidContainer}.
- *
- * @remarks
- *
- * The following is the list of events emitted.
- *
- * ### "connected"
- *
- * The "connected" event is emitted when the `IFluidContainer` completes connecting to the Fluid service.
- *
- * #### Listener signature
- *
- * ```typescript
- * () => void;
- * ```
- *
- * ### "dispose"
- *
- * The "dispose" event is emitted when the `IFluidContainer` is disposed, which permanently disables it.
- *
- * #### Listener signature
- *
- * ```typescript
- * () => void;
- * ```
- *
- * ### "disconnected"
- *
- * The "disconnected" event is emitted when the `IFluidContainer` becomes disconnected from the Fluid service.
- *
- * #### Listener signature
- *
- * ```typescript
- * () => void;
- * ```
- *
- * ### "saved"
- *
- * The "saved" event is emitted when the `IFluidContainer` has local changes acknowledged by the service.
- *
- * #### Listener signature
- *
- * ```typescript
- * () => void
- * ```
- *
- * ### "dirty"
- *
- * The "dirty" event is emitted when the `IFluidContainer` has local changes that have not yet
- * been acknowledged by the service.
- *
- * #### Listener signature
- *
- * ```typescript
- * () => void
- * ```
  */
+/* eslint-disable @typescript-eslint/unified-signatures */
 export interface IFluidContainerEvents extends IEvent {
-    (event: "connected" | "dispose" | "disconnected" | "saved" | "dirty", listener: () => void): void;
+    /**
+     * Emitted when the {@link IFluidContainer} completes connecting to the Fluid service.
+     *
+     * @remarks Reflects connection state changes against the (delta) service acknowledging ops/edits.
+     *
+     * @see
+     *
+     * - {@link IFluidContainer.connectionState}
+     *
+     * - {@link IFluidContainer.disconnect}
+     */
+    (event: "connected", listener: () => void): void;
+
+    /**
+     * Emitted when the {@link IFluidContainer} becomes disconnected from the Fluid service.
+     *
+     * @remarks Reflects connection state changes against the (delta) service acknowledging ops/edits.
+     *
+     * @see
+     *
+     * - {@link IFluidContainer.connectionState}
+     *
+     * - {@link IFluidContainer.disconnect}
+     */
+    (event: "disconnected", listener: () => void): void;
+
+    /**
+     * Emitted when all local changes/edits have been acknowledged by the service.
+     *
+     * @remarks "dirty" event will be emitted when the next local change has been made.
+     *
+     * @see {@link IFluidContainer.isDirty}
+     */
+    (event: "saved", listener: () => void): void;
+
+    /**
+     * Emitted when the first local change has been made, following a "saved" event.
+     *
+     * @remarks "saved" event will be emitted once all local changes have been acknowledged by the service.
+     *
+     * @see {@link IFluidContainer.isDirty}
+     */
+    (event: "dirty", listener: () => void): void;
+
+    /**
+     * Emitted when the {@link IFluidContainer} is closed, which permanently disables it.
+     *
+     * @remarks
+     *
+     * If container was closed due to error (as opposed to an explicit call to
+     * {@link IFluidContainer.dispose}), optional argument contains further details about the error.
+     */
+    (event: "disposed", listener: (error?: ICriticalContainerError) => void);
 }
+/* eslint-enable @typescript-eslint/unified-signatures */
 
 /**
  * Provides an entrypoint into the client side of collaborative Fluid data.
@@ -83,6 +86,9 @@ export interface IFluidContainer extends IEventProvider<IFluidContainerEvents> {
 
     /**
      * A container is considered **dirty** if it has local changes that have not yet been acknowledged by the service.
+     *
+     * @remarks
+     *
      * You should always check the `isDirty` flag before closing the container or navigating away from the page.
      * Closing the container while `isDirty === true` may result in the loss of operations that have not yet been
      * acknowledged by the service.
@@ -101,18 +107,23 @@ export interface IFluidContainer extends IEventProvider<IFluidContainerEvents> {
     readonly isDirty: boolean;
 
     /**
-     * Whether the container is disposed, which permanently disables it.
+     * Whether or not the container is disposed, which permanently disables it.
      */
     readonly disposed: boolean;
 
     /**
      * The collection of data objects and Distributed Data Stores (DDSes) that were specified by the schema.
-     * These data objects and DDSes exist for the lifetime of the container.
+     *
+     * @remarks These data objects and DDSes exist for the lifetime of the container.
      */
     readonly initialObjects: LoadableObjectRecord;
 
     /**
-     * The current attachment state of the container.  Once a container has been attached, it remains attached.
+     * The current attachment state of the container.
+     *
+     * @remarks
+     *
+     * Once a container has been attached, it remains attached.
      * When loading an existing container, it will already be attached.
      */
     readonly attachState: AttachState;
@@ -121,7 +132,9 @@ export interface IFluidContainer extends IEventProvider<IFluidContainerEvents> {
      * A newly created container starts detached from the collaborative service.
      * Calling `attach()` uploads the new container to the service and connects to the collaborative service.
      *
-     * @remarks This should only be called when the container is in the
+     * @remarks
+     *
+     * This should only be called when the container is in the
      * {@link @fluidframework/container-definitions#AttachState.Detatched} state.
      *
      * This can be determined by observing {@link IFluidContainer.attachState}.
@@ -134,7 +147,9 @@ export interface IFluidContainer extends IEventProvider<IFluidContainerEvents> {
      * Attempts to connect the container to the delta stream and process operations.
      * Will throw an error if unsuccessful.
      *
-     * @remarks This should only be called when the container is in the
+     * @remarks
+     *
+     * This should only be called when the container is in the
      * {@link @fluidframework/container-definitions#ConnectionState.Disconnected} state.
      *
      * This can be determined by observing {@link IFluidContainer.connectionState}.
@@ -144,7 +159,9 @@ export interface IFluidContainer extends IEventProvider<IFluidContainerEvents> {
     /**
      * Disconnects the container from the delta stream and stops processing operations.
      *
-     * @remarks This should only be called when the container is in the
+     * @remarks
+     *
+     * This should only be called when the container is in the
      * {@link @fluidframework/container-definitions#ConnectionState.Connected} state.
      *
      * This can be determined by observing {@link IFluidContainer.connectionState}.
@@ -154,11 +171,15 @@ export interface IFluidContainer extends IEventProvider<IFluidContainerEvents> {
     /**
      * Create a new data object or Distributed Data Store (DDS) of the specified type.
      *
-     * @remarks In order to share the data object or DDS with other
+     * @remarks
+     *
+     * In order to share the data object or DDS with other
      * collaborators and retrieve it later, store its handle in a collection like a SharedDirectory from your
      * initialObjects.
      *
-     * @param objectClass - The class of data object or DDS to create
+     * @param objectClass - The class of the `DataObject` or `SharedObject` to create.
+     *
+     * @typeParam T - The class of the `DataObject` or `SharedObject`.
      */
     create<T extends IFluidLoadable>(objectClass: LoadableObjectClass<T>): Promise<T>;
 
@@ -171,19 +192,21 @@ export interface IFluidContainer extends IEventProvider<IFluidContainerEvents> {
 /**
  * Base {@link IFluidContainer} implementation.
  *
- * @remarks Note: this implementation is not complete. Consumers who rely on {@link IFluidContainer.attach}
+ * @remarks
+ *
+ * Note: this implementation is not complete. Consumers who rely on {@link IFluidContainer.attach}
  * will need to utilize or provide a service-specific implementation of this type that implements that method.
  */
 export class FluidContainer extends TypedEventEmitter<IFluidContainerEvents> implements IFluidContainer {
     private readonly connectedHandler = () => this.emit("connected");
     private readonly disconnectedHandler = () => this.emit("disconnected");
-    private readonly disposedHandler = () => this.emit("disposed");
+    private readonly disposedHandler = (error?: ICriticalContainerError) => this.emit("disposed", error);
     private readonly savedHandler = () => this.emit("saved");
     private readonly dirtyHandler = () => this.emit("dirty");
 
     public constructor(
         private readonly container: IContainer,
-        private readonly rootDataObject: RootDataObject,
+        private readonly rootDataObject: IRootDataObject,
     ) {
         super();
         container.on("connected", this.connectedHandler);
@@ -196,7 +219,7 @@ export class FluidContainer extends TypedEventEmitter<IFluidContainerEvents> imp
     /**
      * {@inheritDoc IFluidContainer.isDirty}
      */
-     public get isDirty(): boolean {
+    public get isDirty(): boolean {
         return this.container.isDirty;
     }
 
@@ -217,7 +240,7 @@ export class FluidContainer extends TypedEventEmitter<IFluidContainerEvents> imp
     /**
      * {@inheritDoc IFluidContainer.connectionState}
      */
-     public get connectionState(): ConnectionState {
+    public get connectionState(): ConnectionState {
         return this.container.connectionState;
     }
 
@@ -230,7 +253,10 @@ export class FluidContainer extends TypedEventEmitter<IFluidContainerEvents> imp
 
     /**
      * Incomplete base implementation of {@link IFluidContainer.attach}.
-     * @remarks Note: this implementation will unconditionally throw.
+     *
+     * @remarks
+     *
+     * Note: this implementation will unconditionally throw.
      * Consumers who rely on this will need to utilize or provide a service specific implementation of this base type
      * that provides an implementation of this method.
      *
@@ -238,7 +264,10 @@ export class FluidContainer extends TypedEventEmitter<IFluidContainerEvents> imp
      * but internally this separation is not there.
      */
     public async attach(): Promise<string> {
-        throw new Error("Cannot attach container. Container is not in detached state");
+        if (this.container.attachState !== AttachState.Detached) {
+            throw new Error("Cannot attach container. Container is not in detached state.");
+        }
+        throw new Error("Cannot attach container. Attach method not provided.");
     }
 
     /**

package/src/index.ts

@@ -9,7 +9,22 @@
  * @packageDocumentation
  */
 
-export * from "./fluidContainer";
-export * from "./rootDataObject";
-export * from "./serviceAudience";
-export * from "./types";
+export { FluidContainer, IFluidContainer, IFluidContainerEvents } from "./fluidContainer";
+export { DOProviderContainerRuntimeFactory, RootDataObject, RootDataObjectProps } from "./rootDataObject";
+export { ServiceAudience } from "./serviceAudience";
+export {
+	ContainerSchema,
+	DataObjectClass,
+	IConnection,
+	IMember,
+	IRootDataObject,
+	IServiceAudience,
+	IServiceAudienceEvents,
+	LoadableObjectClass,
+	LoadableObjectClassRecord,
+	LoadableObjectCtor,
+	LoadableObjectRecord,
+	MemberChangedListener,
+	SharedObjectClass,
+    Myself,
+} from "./types";

package/src/rootDataObject.ts

@@ -11,10 +11,10 @@ import {
 import { IContainerRuntime } from "@fluidframework/container-runtime-definitions";
 import { IFluidLoadable } from "@fluidframework/core-interfaces";
 import { FlushMode } from "@fluidframework/runtime-definitions";
-import { requestFluidObject } from "@fluidframework/runtime-utils";
 import {
     ContainerSchema,
     DataObjectClass,
+    IRootDataObject,
     LoadableObjectClass,
     LoadableObjectClassRecord,
     LoadableObjectRecord,
@@ -23,22 +23,22 @@ import {
 import { isDataObjectClass, isSharedObjectClass, parseDataObjectsFromSharedObjects } from "./utils";
 
 /**
- * Input props for {@link RootDataObject.initializingFirstTime}
+ * Input props for {@link RootDataObject.initializingFirstTime}.
  */
 export interface RootDataObjectProps {
     /**
      * Initial object structure with which the {@link RootDataObject} will be first-time initialized.
-     * See {@link RootDataObject.initializingFirstTime}
+     *
+     * @see {@link RootDataObject.initializingFirstTime}
      */
     initialObjects: LoadableObjectClassRecord;
 }
 
 /**
- * The entry-point/root collaborative object of the Fluid Container.
- * This class abstracts the dynamic code required to build a Fluid Container into a static representation
- * for end customers.
+ * The entry-point/root collaborative object of the {@link IFluidContainer | Fluid Container}.
+ * Abstracts the dynamic code required to build a Fluid Container into a static representation for end customers.
  */
-export class RootDataObject extends DataObject<{ InitialState: RootDataObjectProps; }> {
+export class RootDataObject extends DataObject<{ InitialState: RootDataObjectProps; }> implements IRootDataObject {
     private readonly initialObjectsDirKey = "initial-objects-key";
     private readonly _initialObjects: LoadableObjectRecord = {};
 
@@ -54,7 +54,7 @@ export class RootDataObject extends DataObject<{ InitialState: RootDataObjectPro
      * The first time this object is initialized, creates each object identified in
      * {@link RootDataObjectProps.initialObjects} and stores them as unique values in the root directory.
      *
-     * See {@link @fluidframework/aqueduct#PureDataObject.initializingFirstTime}
+     * @see {@link @fluidframework/aqueduct#PureDataObject.initializingFirstTime}
      */
     protected async initializingFirstTime(props: RootDataObjectProps) {
         this.root.createSubDirectory(this.initialObjectsDirKey);
@@ -76,7 +76,7 @@ export class RootDataObject extends DataObject<{ InitialState: RootDataObjectPro
      * Every time an instance is initialized, loads all of the initial objects in the root directory so they can be
      * accessed immediately.
      *
-     * See {@link @fluidframework/aqueduct#PureDataObject.hasInitialized}
+     * @see {@link @fluidframework/aqueduct#PureDataObject.hasInitialized}
      */
     protected async hasInitialized() {
         // We will always load the initial objects so they are available to the developer
@@ -93,8 +93,7 @@ export class RootDataObject extends DataObject<{ InitialState: RootDataObjectPro
     }
 
     /**
-     * Provides a record of the initial objects defined on creation.
-     * See {@link RootDataObject.initializingFirstTime}
+     * {@inheritDoc IRootDataObject.initialObjects}
      */
     public get initialObjects(): LoadableObjectRecord {
         if (Object.keys(this._initialObjects).length === 0) {
@@ -104,8 +103,7 @@ export class RootDataObject extends DataObject<{ InitialState: RootDataObjectPro
     }
 
     /**
-     * Dynamically creates a new detached collaborative object (DDS/DataObject).
-     * @param objectClass - Type of the collaborative object to be created.
+     * {@inheritDoc IRootDataObject.create}
      */
     public async create<T extends IFluidLoadable>(
         objectClass: LoadableObjectClass<T>,
@@ -121,8 +119,9 @@ export class RootDataObject extends DataObject<{ InitialState: RootDataObjectPro
     private async createDataObject<T extends IFluidLoadable>(dataObjectClass: DataObjectClass<T>): Promise<T> {
         const factory = dataObjectClass.factory;
         const packagePath = [...this.context.packagePath, factory.type];
-        const router = await this.context.containerRuntime.createDataStore(packagePath);
-        return requestFluidObject<T>(router, "/");
+        const dataStore = await this.context.containerRuntime.createDataStore(packagePath);
+        const entryPoint = await dataStore.entryPoint?.get();
+        return entryPoint as unknown as T;
     }
 
     private createSharedObject<T extends IFluidLoadable>(
@@ -137,8 +136,12 @@ export class RootDataObject extends DataObject<{ InitialState: RootDataObjectPro
 const rootDataStoreId = "rootDOId";
 
 /**
- * Container code that provides a single {@link RootDataObject}.  This data object is
- * dynamically customized (registry and initial objects) based on the schema provided to the container runtime factory.
+ * Container code that provides a single {@link RootDataObject}.
+ *
+ * @remarks
+ *
+ * This data object is dynamically customized (registry and initial objects) based on the schema provided.
+ * to the container runtime factory.
  */
 export class DOProviderContainerRuntimeFactory extends BaseContainerRuntimeFactory {
     private readonly rootDataObjectFactory: DataObjectFactory<RootDataObject, {

package/src/serviceAudience.ts

@@ -6,32 +6,42 @@
 import { TypedEventEmitter } from "@fluidframework/common-utils";
 import { IAudience, IContainer } from "@fluidframework/container-definitions";
 import { IClient } from "@fluidframework/protocol-definitions";
-import { IServiceAudience, IServiceAudienceEvents, IMember } from "./types";
+import { IServiceAudience, IServiceAudienceEvents, IMember, Myself } from "./types";
 
 /**
- * Base class for providing audience information for sessions interacting with FluidContainer
+ * Base class for providing audience information for sessions interacting with {@link IFluidContainer}
+ *
+ * @remarks
+ *
  * This can be extended by different service-specific client packages to additional parameters to
- * the user and client details returned in IMember
- * @typeParam M - A service-specific member type.
+ * the user and client details returned in {@link IMember}.
+ *
+ * @typeParam M - A service-specific {@link IMember} implementation.
  */
 export abstract class ServiceAudience<M extends IMember = IMember>
   extends TypedEventEmitter<IServiceAudienceEvents<M>>
   implements IServiceAudience<M> {
   /**
-   * Audience object which includes all the existing members of the container.
+   * Audience object which includes all the existing members of the {@link IFluidContainer | container}.
    */
   protected readonly audience: IAudience;
 
   /**
-   * Retain the most recent member list.  This is so we have more information about a member
-   * leaving the audience in the removeMember event.  It allows us to match the behavior of the
-   * addMember event where it only fires on a change to the members this class exposes (and would
-   * actually produce a change in what getMembers returns).  It also allows us to provide the
-   * client details in the event which makes it easier to find that client connection in a map
-   * keyed on the userId and not clientId.
-   * This map will always be up-to-date in a removeMember event because it is set once at
-   * construction and in every addMember event.
-   * It is mapped clientId to M to be better work with what the IAudience event provides
+   * Retain the most recent member list.
+   *
+   * @remarks
+   *
+   * This is so we have more information about a member leaving the audience in the `removeMember` event.
+   *
+   * It allows us to match the behavior of the `addMember` event where it only fires on a change to the members this
+   * class exposes (and would actually produce a change in what `getMembers` returns).
+   *
+   * It also allows us to provide the client details in the event which makes it easier to find that client connection
+   * in a map keyed on the `userId` and not `clientId`.
+   *
+   * This map will always be up-to-date in a `removeMember` event because it is set once at construction and in
+   * every `addMember` event. It is mapped `clientId` to `M` to be better work with what the {@link IServiceAudience}
+   * events provide.
    */
   protected lastMembers: Map<string, M> = new Map();
 
@@ -68,6 +78,7 @@ export abstract class ServiceAudience<M extends IMember = IMember>
 
   /**
    * Provides ability for inheriting class to modify/extend the audience object.
+   *
    * @param audienceMember - Record of a specific audience member.
    */
   protected abstract createServiceMember(audienceMember: IClient): M;
@@ -101,12 +112,20 @@ export abstract class ServiceAudience<M extends IMember = IMember>
   /**
    * {@inheritDoc IServiceAudience.getMyself}
    */
-  public getMyself(): M | undefined {
+  public getMyself(): Myself<M> | undefined {
     const clientId = this.container.clientId;
     if (clientId === undefined) {
       return undefined;
     }
-    return this.getMember(clientId);
+
+    const member = this.getMember(clientId);
+    if (member === undefined) {
+        return undefined;
+      }
+
+    const myself: Myself<M> = { ...member, currentConnection: clientId };
+
+    return myself;
   }
 
   private getMember(clientId: string): M | undefined {
@@ -127,6 +146,7 @@ export abstract class ServiceAudience<M extends IMember = IMember>
   /**
    * Provides ability for the inheriting class to include/omit specific members.
    * An example use case is omitting the summarizer client.
+   *
    * @param member - Member to be included/omitted.
    */
   protected shouldIncludeAsMember(member: IClient): boolean {