@fluidframework/fluid-static 2.0.0-internal.7.0.1 → 2.0.0-internal.7.1.1

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # @fluidframework/fluid-static
 
+## 2.0.0-internal.7.1.0
+
+Dependency updates only.
+
 ## 2.0.0-internal.7.0.0
 
 ### Major Changes

package/api-extractor.json

@@ -1,4 +1,12 @@
 {
 	"$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
-	"extends": "@fluidframework/build-common/api-extractor-common-strict.json"
+	"extends": "@fluidframework/build-common/api-extractor-base.json",
+	"messages": {
+		"extractorMessageReporting": {
+			"ae-missing-release-tag": {
+				// TODO: Fix violations and remove this rule override
+				"logLevel": "none"
+			}
+		}
+	}
 }

package/api-report/fluid-static.api.md

@@ -0,0 +1,152 @@
+## API Report File for "@fluidframework/fluid-static"
+
+> Do not edit this file. It is a report generated by [API Extractor](https://api-extractor.com/).
+
+```ts
+
+import { AttachState } from '@fluidframework/container-definitions';
+import { BaseContainerRuntimeFactory } from '@fluidframework/aqueduct';
+import { ConnectionState } from '@fluidframework/container-definitions';
+import { IAudience } from '@fluidframework/container-definitions';
+import { IChannelFactory } from '@fluidframework/datastore-definitions';
+import { IClient } from '@fluidframework/protocol-definitions';
+import { IContainer } from '@fluidframework/container-definitions';
+import { IContainerRuntime } from '@fluidframework/container-runtime-definitions';
+import { ICriticalContainerError } from '@fluidframework/container-definitions';
+import { IEvent } from '@fluidframework/core-interfaces';
+import { IEventProvider } from '@fluidframework/core-interfaces';
+import { IFluidDataStoreFactory } from '@fluidframework/runtime-definitions';
+import { IFluidLoadable } from '@fluidframework/core-interfaces';
+import { TypedEventEmitter } from '@fluid-internal/client-utils';
+
+// @public
+export interface ContainerSchema {
+    dynamicObjectTypes?: LoadableObjectClass<any>[];
+    initialObjects: LoadableObjectClassRecord;
+}
+
+// @public
+export type DataObjectClass<T extends IFluidLoadable> = {
+    readonly factory: IFluidDataStoreFactory;
+} & LoadableObjectCtor<T>;
+
+// @public
+export class DOProviderContainerRuntimeFactory extends BaseContainerRuntimeFactory {
+    constructor(schema: ContainerSchema);
+    // (undocumented)
+    protected containerInitializingFirstTime(runtime: IContainerRuntime): Promise<void>;
+}
+
+// @public
+export class FluidContainer extends TypedEventEmitter<IFluidContainerEvents> implements IFluidContainer {
+    constructor(container: IContainer, rootDataObject: IRootDataObject);
+    attach(): Promise<string>;
+    get attachState(): AttachState;
+    connect(): Promise<void>;
+    get connectionState(): ConnectionState;
+    create<T extends IFluidLoadable>(objectClass: LoadableObjectClass<T>): Promise<T>;
+    disconnect(): Promise<void>;
+    dispose(): void;
+    get disposed(): boolean;
+    get initialObjects(): LoadableObjectRecord;
+    // @internal
+    readonly INTERNAL_CONTAINER_DO_NOT_USE?: () => IContainer;
+    get isDirty(): boolean;
+}
+
+// @public
+export interface IConnection {
+    id: string;
+    mode: "write" | "read";
+}
+
+// @public
+export interface IFluidContainer extends IEventProvider<IFluidContainerEvents> {
+    attach(): Promise<string>;
+    readonly attachState: AttachState;
+    connect(): void;
+    readonly connectionState: ConnectionState;
+    create<T extends IFluidLoadable>(objectClass: LoadableObjectClass<T>): Promise<T>;
+    disconnect(): void;
+    dispose(): void;
+    readonly disposed: boolean;
+    readonly initialObjects: LoadableObjectRecord;
+    readonly isDirty: boolean;
+}
+
+// @public
+export interface IFluidContainerEvents extends IEvent {
+    (event: "connected", listener: () => void): void;
+    (event: "disconnected", listener: () => void): void;
+    (event: "saved", listener: () => void): void;
+    (event: "dirty", listener: () => void): void;
+    (event: "disposed", listener: (error?: ICriticalContainerError) => void): any;
+}
+
+// @public
+export interface IMember {
+    connections: IConnection[];
+    userId: string;
+}
+
+// @public
+export interface IRootDataObject {
+    create<T extends IFluidLoadable>(objectClass: LoadableObjectClass<T>): Promise<T>;
+    readonly initialObjects: LoadableObjectRecord;
+}
+
+// @public
+export interface IServiceAudience<M extends IMember> extends IEventProvider<IServiceAudienceEvents<M>> {
+    getMembers(): Map<string, M>;
+    getMyself(): Myself<M> | undefined;
+}
+
+// @public
+export interface IServiceAudienceEvents<M extends IMember> extends IEvent {
+    // @eventProperty
+    (event: "membersChanged", listener: () => void): void;
+    // @eventProperty
+    (event: "memberAdded", listener: MemberChangedListener<M>): void;
+    // @eventProperty
+    (event: "memberRemoved", listener: MemberChangedListener<M>): void;
+}
+
+// @public
+export type LoadableObjectClass<T extends IFluidLoadable> = DataObjectClass<T> | SharedObjectClass<T>;
+
+// @public
+export type LoadableObjectClassRecord = Record<string, LoadableObjectClass<any>>;
+
+// @public
+export type LoadableObjectCtor<T extends IFluidLoadable> = new (...args: any[]) => T;
+
+// @public
+export type LoadableObjectRecord = Record<string, IFluidLoadable>;
+
+// @public
+export type MemberChangedListener<M extends IMember> = (clientId: string, member: M) => void;
+
+// @public
+export type Myself<M extends IMember = IMember> = M & {
+    currentConnection: string;
+};
+
+// @public
+export abstract class ServiceAudience<M extends IMember = IMember> extends TypedEventEmitter<IServiceAudienceEvents<M>> implements IServiceAudience<M> {
+    constructor(
+    container: IContainer);
+    protected readonly audience: IAudience;
+    protected readonly container: IContainer;
+    protected abstract createServiceMember(audienceMember: IClient): M;
+    getMembers(): Map<string, M>;
+    getMyself(): Myself<M> | undefined;
+    protected lastMembers: Map<string, M>;
+    protected shouldIncludeAsMember(member: IClient): boolean;
+}
+
+// @public
+export type SharedObjectClass<T extends IFluidLoadable> = {
+    readonly getFactory: () => IChannelFactory;
+} & LoadableObjectCtor<T>;
+
+```