@fluidframework/container-loader 2.0.0-dev.2.3.0.115467 → 2.0.0-dev.4.1.0.148229

package/src/deltaManagerProxy.ts

@@ -4,155 +4,106 @@
  */
 
 import {
-    IDeltaManager,
-    IDeltaManagerEvents,
-    IDeltaQueue,
-    IDeltaSender,
-    IDeltaQueueEvents,
-    ReadOnlyInfo,
+	IDeltaManager,
+	IDeltaQueue,
+	IDeltaQueueEvents,
 } from "@fluidframework/container-definitions";
 import { EventForwarder } from "@fluidframework/common-utils";
 import {
-    IClientConfiguration,
-    IClientDetails,
-    IDocumentMessage,
-    ISequencedDocumentMessage,
-    ISignalMessage,
+	IDocumentMessage,
+	ISequencedDocumentMessage,
+	ISignalMessage,
 } from "@fluidframework/protocol-definitions";
+import { DeltaManagerProxyBase } from "@fluidframework/container-utils";
 
 /**
  * Proxy to the real IDeltaQueue - used to restrict access
  */
-export class DeltaQueueProxy<T> extends EventForwarder<IDeltaQueueEvents<T>> implements IDeltaQueue<T> {
-    public get paused(): boolean {
-        return this.queue.paused;
-    }
-
-    public get length(): number {
-        return this.queue.length;
-    }
-
-    public get idle(): boolean {
-        return this.queue.idle;
-    }
-
-    constructor(private readonly queue: IDeltaQueue<T>) {
-        super(queue);
-    }
-
-    public peek(): T | undefined {
-        return this.queue.peek();
-    }
-
-    public toArray(): T[] {
-        return this.queue.toArray();
-    }
-
-    // back-compat: usage removed in 0.33, remove in future versions
-    public async systemPause(): Promise<void> {
-        return this.pause();
-    }
-
-    public async pause(): Promise<void> {
-        return this.queue.pause();
-    }
-
-    // back-compat: usage removed in 0.33, remove in future versions
-    public async systemResume(): Promise<void> {
-        return this.resume();
-    }
-
-    public async resume(): Promise<void> {
-        this.queue.resume();
-    }
-
-    public async waitTillProcessingDone() {
-        return this.queue.waitTillProcessingDone();
-    }
+export class DeltaQueueProxy<T>
+	extends EventForwarder<IDeltaQueueEvents<T>>
+	implements IDeltaQueue<T>
+{
+	public get paused(): boolean {
+		return this.queue.paused;
+	}
+
+	public get length(): number {
+		return this.queue.length;
+	}
+
+	public get idle(): boolean {
+		return this.queue.idle;
+	}
+
+	constructor(private readonly queue: IDeltaQueue<T>) {
+		super(queue);
+	}
+
+	public peek(): T | undefined {
+		return this.queue.peek();
+	}
+
+	public toArray(): T[] {
+		return this.queue.toArray();
+	}
+
+	// back-compat: usage removed in 0.33, remove in future versions
+	public async systemPause(): Promise<void> {
+		return this.pause();
+	}
+
+	public async pause(): Promise<void> {
+		return this.queue.pause();
+	}
+
+	// back-compat: usage removed in 0.33, remove in future versions
+	public async systemResume(): Promise<void> {
+		return this.resume();
+	}
+
+	public async resume(): Promise<void> {
+		this.queue.resume();
+	}
+
+	public async waitTillProcessingDone() {
+		return this.queue.waitTillProcessingDone();
+	}
 }
 
 /**
  * Proxy to the real IDeltaManager - used to restrict access
  */
 export class DeltaManagerProxy
-    extends EventForwarder<IDeltaManagerEvents>
-    implements IDeltaManager<ISequencedDocumentMessage, IDocumentMessage> {
-    public readonly inbound: IDeltaQueue<ISequencedDocumentMessage>;
-    public readonly outbound: IDeltaQueue<IDocumentMessage[]>;
-    public readonly inboundSignal: IDeltaQueue<ISignalMessage>;
-
-    public get IDeltaSender(): IDeltaSender {
-        return this;
-    }
-
-    public get minimumSequenceNumber(): number {
-        return this.deltaManager.minimumSequenceNumber;
-    }
-
-    public get lastSequenceNumber(): number {
-        return this.deltaManager.lastSequenceNumber;
-    }
-
-    public get lastMessage() {
-        return this.deltaManager.lastMessage;
-    }
-
-    public get lastKnownSeqNumber() {
-        return this.deltaManager.lastKnownSeqNumber;
-    }
-
-    public get initialSequenceNumber(): number {
-        return this.deltaManager.initialSequenceNumber;
-    }
-
-    public get hasCheckpointSequenceNumber() {
-        return this.deltaManager.hasCheckpointSequenceNumber;
-    }
-
-    public get clientDetails(): IClientDetails {
-        return this.deltaManager.clientDetails;
-    }
-
-    public get version(): string {
-        return this.deltaManager.version;
-    }
-
-    public get maxMessageSize(): number {
-        return this.deltaManager.maxMessageSize;
-    }
-
-    public get serviceConfiguration(): IClientConfiguration | undefined {
-        return this.deltaManager.serviceConfiguration;
-    }
-
-    public get active(): boolean {
-        return this.deltaManager.active;
-    }
-
-    public get readOnlyInfo(): ReadOnlyInfo {
-        return this.deltaManager.readOnlyInfo;
-    }
-
-    constructor(private readonly deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>) {
-        super(deltaManager);
-
-        this.inbound = new DeltaQueueProxy(deltaManager.inbound);
-        this.outbound = new DeltaQueueProxy(deltaManager.outbound);
-        this.inboundSignal = new DeltaQueueProxy(deltaManager.inboundSignal);
-    }
-
-    public dispose(): void {
-        this.inbound.dispose();
-        this.outbound.dispose();
-        this.inboundSignal.dispose();
-        super.dispose();
-    }
-
-    public submitSignal(content: any): void {
-        return this.deltaManager.submitSignal(content);
-    }
-
-    public flush(): void {
-        return this.deltaManager.flush();
-    }
+	extends DeltaManagerProxyBase
+	implements IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>
+{
+	public get inbound(): IDeltaQueue<ISequencedDocumentMessage> {
+		return this._inbound;
+	}
+	private readonly _inbound: IDeltaQueue<ISequencedDocumentMessage>;
+
+	public get outbound(): IDeltaQueue<IDocumentMessage[]> {
+		return this._outbound;
+	}
+	private readonly _outbound: IDeltaQueue<IDocumentMessage[]>;
+
+	public get inboundSignal(): IDeltaQueue<ISignalMessage> {
+		return this._inboundSignal;
+	}
+	private readonly _inboundSignal: IDeltaQueue<ISignalMessage>;
+
+	constructor(deltaManager: IDeltaManager<ISequencedDocumentMessage, IDocumentMessage>) {
+		super(deltaManager);
+
+		this._inbound = new DeltaQueueProxy(deltaManager.inbound);
+		this._outbound = new DeltaQueueProxy(deltaManager.outbound);
+		this._inboundSignal = new DeltaQueueProxy(deltaManager.inboundSignal);
+	}
+
+	public dispose(): void {
+		this._inbound.dispose();
+		this._outbound.dispose();
+		this._inboundSignal.dispose();
+		super.dispose();
+	}
 }

package/src/deltaQueue.ts

@@ -8,158 +8,162 @@ import { assert, performance, TypedEventEmitter } from "@fluidframework/common-u
 import Deque from "double-ended-queue";
 
 export interface IDeltaQueueWriter<T> {
-    push(task: T): void;
-    clear(): void;
+	push(task: T): void;
+	clear(): void;
 }
 
 export class DeltaQueue<T>
-    extends TypedEventEmitter<IDeltaQueueEvents<T>>
-    implements IDeltaQueue<T>, IDeltaQueueWriter<T> {
-    private isDisposed: boolean = false;
-    private readonly q = new Deque<T>();
-
-    /**
-     * Tracks the number of pause requests for the queue
-     * The DeltaQueue is create initially paused.
-     */
-    private pauseCount = 1;
-
-    private error: any | undefined;
-
-    /**
-     * When processing is ongoing, holds a deferred that will resolve once processing stops.
-     * Undefined when not processing.
-     */
-    private processingPromise: Promise<{ count: number; duration: number; }> | undefined;
-
-    public get disposed(): boolean {
-        return this.isDisposed;
-    }
-
-    /**
-     * @returns True if the queue is paused, false if not.
-     */
-    public get paused(): boolean {
-        return this.pauseCount !== 0;
-    }
-
-    public get length(): number {
-        return this.q.length;
-    }
-
-    public get idle(): boolean {
-        return this.processingPromise === undefined && this.q.length === 0;
-    }
-
-    public async waitTillProcessingDone() {
-        return this.processingPromise ?? { count: 0, duration: 0 };
-    }
-
-    /**
-     * @param worker - A callback to process a delta.
-     * @param logger - For logging telemetry.
-     */
-    constructor(
-        private readonly worker: (delta: T) => void,
-    ) {
-        super();
-    }
-
-    public dispose() {
-        throw new Error("Not implemented.");
-        this.isDisposed = true;
-    }
-
-    public clear(): void {
-        this.q.clear();
-    }
-
-    public peek(): T | undefined {
-        return this.q.peekFront();
-    }
-
-    public toArray(): T[] {
-        return this.q.toArray();
-    }
-
-    public push(task: T) {
-        try {
-            this.q.push(task);
-            this.emit("push", task);
-            this.ensureProcessing();
-        } catch (error) {
-            this.emit("error", error);
-        }
-    }
-
-    public async pause(): Promise<void> {
-        this.pauseCount++;
-        // If called from within the processing loop, we are in the middle of processing an op. Return a promise
-        // that will resolve when processing has actually stopped.
-        await this.waitTillProcessingDone();
-    }
-
-    public resume(): void {
-        assert(this.pauseCount > 0, 0x0f4 /* "Nonzero pause-count on resume()" */);
-        this.pauseCount--;
-        this.ensureProcessing();
-    }
-
-    /**
-     * There are several actions that may need to kick off delta processing, so we want to guard against
-     * accidental reentrancy. ensureProcessing can be called safely to start the processing loop if it is
-     * not already started.
-     */
-    private ensureProcessing() {
-        if (this.anythingToProcess() && this.processingPromise === undefined) {
-            // Use a resolved promise to start the processing on a separate stack.
-            this.processingPromise = Promise.resolve().then(() => {
-                assert(this.processingPromise !== undefined, 0x37f /* reentrancy? */);
-                const result = this.processDeltas();
-                assert(this.processingPromise !== undefined, 0x380 /* reentrancy? */);
-                // WARNING: Do not move next line to .finally() clause!
-                // It runs async and creates a race condition where incoming ensureProcessing() call observes
-                // from previous run while previous run is over (but finally clause was not scheduled yet)
-                this.processingPromise = undefined;
-                return result;
-            }).catch((error) => {
-                this.error = error;
-                this.processingPromise = undefined;
-                this.emit("error", error);
-                return { count: 0, duration: 0 };
-            });
-            assert(this.processingPromise !== undefined, 0x381 /* processDeltas() should run async */);
-        }
-    }
-
-    private anythingToProcess() {
-        return this.q.length !== 0 && !this.paused && this.error === undefined;
-    }
-
-    /**
-     * Executes the delta processing loop until a stop condition is reached.
-     */
-    private processDeltas() {
-        const start = performance.now();
-        let count = 0;
-
-        // For grouping to work we must process all local messages immediately and in the single turn.
-        // So loop over them until no messages to process, we have become paused, or hit an error.
-        while (this.anythingToProcess()) {
-            // Get the next message in the queue
-            const next = this.q.shift();
-            count++;
-            // Process the message.
-            // We know next is defined since we did a length check just prior to shifting.
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            this.worker(next!);
-            this.emit("op", next);
-        }
-
-        const duration = performance.now() - start;
-        if (this.q.length === 0) {
-            this.emit("idle", count, duration);
-        }
-        return { count, duration };
-    }
+	extends TypedEventEmitter<IDeltaQueueEvents<T>>
+	implements IDeltaQueue<T>, IDeltaQueueWriter<T>
+{
+	private isDisposed: boolean = false;
+	private readonly q = new Deque<T>();
+
+	/**
+	 * Tracks the number of pause requests for the queue
+	 * The DeltaQueue is create initially paused.
+	 */
+	private pauseCount = 1;
+
+	private error: any | undefined;
+
+	/**
+	 * When processing is ongoing, holds a deferred that will resolve once processing stops.
+	 * Undefined when not processing.
+	 */
+	private processingPromise: Promise<{ count: number; duration: number }> | undefined;
+
+	public get disposed(): boolean {
+		return this.isDisposed;
+	}
+
+	/**
+	 * @returns True if the queue is paused, false if not.
+	 */
+	public get paused(): boolean {
+		return this.pauseCount !== 0;
+	}
+
+	public get length(): number {
+		return this.q.length;
+	}
+
+	public get idle(): boolean {
+		return this.processingPromise === undefined && this.q.length === 0;
+	}
+
+	public async waitTillProcessingDone() {
+		return this.processingPromise ?? { count: 0, duration: 0 };
+	}
+
+	/**
+	 * @param worker - A callback to process a delta.
+	 * @param logger - For logging telemetry.
+	 */
+	constructor(private readonly worker: (delta: T) => void) {
+		super();
+	}
+
+	public dispose() {
+		throw new Error("Not implemented.");
+		this.isDisposed = true;
+	}
+
+	public clear(): void {
+		this.q.clear();
+	}
+
+	public peek(): T | undefined {
+		return this.q.peekFront();
+	}
+
+	public toArray(): T[] {
+		return this.q.toArray();
+	}
+
+	public push(task: T) {
+		try {
+			this.q.push(task);
+			this.emit("push", task);
+			this.ensureProcessing();
+		} catch (error) {
+			this.emit("error", error);
+		}
+	}
+
+	public async pause(): Promise<void> {
+		this.pauseCount++;
+		// If called from within the processing loop, we are in the middle of processing an op. Return a promise
+		// that will resolve when processing has actually stopped.
+		await this.waitTillProcessingDone();
+	}
+
+	public resume(): void {
+		assert(this.pauseCount > 0, 0x0f4 /* "Nonzero pause-count on resume()" */);
+		this.pauseCount--;
+		this.ensureProcessing();
+	}
+
+	/**
+	 * There are several actions that may need to kick off delta processing, so we want to guard against
+	 * accidental reentrancy. ensureProcessing can be called safely to start the processing loop if it is
+	 * not already started.
+	 */
+	private ensureProcessing() {
+		if (this.anythingToProcess() && this.processingPromise === undefined) {
+			// Use a resolved promise to start the processing on a separate stack.
+			this.processingPromise = Promise.resolve()
+				.then(() => {
+					assert(this.processingPromise !== undefined, 0x37f /* reentrancy? */);
+					const result = this.processDeltas();
+					assert(this.processingPromise !== undefined, 0x380 /* reentrancy? */);
+					// WARNING: Do not move next line to .finally() clause!
+					// It runs async and creates a race condition where incoming ensureProcessing() call observes
+					// from previous run while previous run is over (but finally clause was not scheduled yet)
+					this.processingPromise = undefined;
+					return result;
+				})
+				.catch((error) => {
+					this.error = error;
+					this.processingPromise = undefined;
+					this.emit("error", error);
+					return { count: 0, duration: 0 };
+				});
+			assert(
+				this.processingPromise !== undefined,
+				0x381 /* processDeltas() should run async */,
+			);
+		}
+	}
+
+	private anythingToProcess() {
+		return this.q.length !== 0 && !this.paused && this.error === undefined;
+	}
+
+	/**
+	 * Executes the delta processing loop until a stop condition is reached.
+	 */
+	private processDeltas() {
+		const start = performance.now();
+		let count = 0;
+
+		// For grouping to work we must process all local messages immediately and in the single turn.
+		// So loop over them until no messages to process, we have become paused, or hit an error.
+		while (this.anythingToProcess()) {
+			// Get the next message in the queue
+			const next = this.q.shift();
+			count++;
+			// Process the message.
+			// We know next is defined since we did a length check just prior to shifting.
+			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+			this.worker(next!);
+			this.emit("op", next);
+		}
+
+		const duration = performance.now() - start;
+		if (this.q.length === 0) {
+			this.emit("idle", count, duration);
+		}
+		return { count, duration };
+	}
 }

package/src/index.ts

@@ -5,23 +5,19 @@
 
 export { ConnectionState } from "./connectionState";
 export {
-    Container,
-    IContainerLoadOptions,
-    IContainerConfig,
-    IPendingContainerState,
-    waitContainerToCatchUp,
+	IContainerConfig,
+	IContainerLoadOptions,
+	IPendingContainerState,
+	waitContainerToCatchUp,
 } from "./container";
+export { ISerializableBlobContents } from "./containerStorageAdapter";
 export {
-    ICodeDetailsLoader,
-    IDetachedBlobStorage,
-    IFluidModuleWithDetails,
-    ILoaderOptions,
-    ILoaderProps,
-    ILoaderServices,
-    Loader,
-    RelativeLoader,
+	ICodeDetailsLoader,
+	IDetachedBlobStorage,
+	IFluidModuleWithDetails,
+	ILoaderOptions,
+	ILoaderProps,
+	ILoaderServices,
+	Loader,
 } from "./loader";
-export {
-    IProtocolHandler,
-    ProtocolHandlerBuilder,
-} from "./protocol";
+export { IProtocolHandler, ProtocolHandlerBuilder } from "./protocol";