@fluidframework/container-loader 2.0.2 → 2.1.0-276326

package/src/containerContext.ts

@@ -74,15 +74,17 @@ export class ContainerContext implements IContainerContext {
 		public readonly loader: ILoader,
 		public readonly submitFn: (
 			type: MessageType,
-			contents: any,
+			contents: unknown,
 			batch: boolean,
-			appData: any,
+			appData: unknown,
 		) => number,
 		public readonly submitSummaryFn: (
 			summaryOp: ISummaryContent,
 			referenceSequenceNumber?: number,
 		) => number,
-		/** @returns clientSequenceNumber of last message in a batch */
+		/**
+		 * @returns clientSequenceNumber of last message in a batch
+		 */
 		public readonly submitBatchFn: (
 			batch: IBatchMessage[],
 			referenceSequenceNumber?: number,

package/src/containerStorageAdapter.ts

@@ -57,7 +57,7 @@ export class ContainerStorageAdapter
 	/**
 	 * Whether the adapter will enforce sending combined summary trees.
 	 */
-	public get summarizeProtocolTree() {
+	public get summarizeProtocolTree(): boolean {
 		return this._summarizeProtocolTree === true;
 	}
 
@@ -77,7 +77,7 @@ export class ContainerStorageAdapter
 	 * @param loadingGroupIdSnapshotsFromPendingState - in offline mode, any loading group snapshots we've downloaded from the service that were stored in the pending state
 	 * @param addProtocolSummaryIfMissing - a callback to permit the container to inspect the summary we're about to
 	 * upload, and fix it up with a protocol tree if needed
-	 * @param enableSummarizeProtocolTree  - Enable uploading a protocol summary. Note: preference is given to service policy's "summarizeProtocolTree" before this value.
+	 * @param enableSummarizeProtocolTree - Enable uploading a protocol summary. Note: preference is given to service policy's "summarizeProtocolTree" before this value.
 	 */
 	public constructor(
 		// eslint-disable-next-line import/no-deprecated
@@ -140,13 +140,13 @@ export class ContainerStorageAdapter
 		);
 	}
 
-	public loadSnapshotFromSnapshotBlobs(snapshotBlobs: ISerializableBlobContents) {
+	public loadSnapshotFromSnapshotBlobs(snapshotBlobs: ISerializableBlobContents): void {
 		for (const [id, value] of Object.entries(snapshotBlobs)) {
 			this.blobContents[id] = value;
 		}
 	}
 
-	public clearPendingState() {
+	public clearPendingState(): void {
 		this.loadingGroupIdSnapshotsFromPendingState = undefined;
 	}
 
@@ -155,13 +155,17 @@ export class ContainerStorageAdapter
 		// and storage is always present in >=0.41.
 		try {
 			return this._storageService.policies;
-		} catch (e) {}
+		} catch {
+			// No-op
+		}
 		return undefined;
 	}
 
 	public async getSnapshotTree(
 		version?: IVersion,
 		scenarioName?: string,
+		// API called below uses null
+		// eslint-disable-next-line @rushstack/no-new-null
 	): Promise<ISnapshotTree | null> {
 		return this._storageService.getSnapshotTree(version, scenarioName);
 	}
@@ -220,6 +224,8 @@ export class ContainerStorageAdapter
 	}
 
 	public async getVersions(
+		// API used below uses null
+		// eslint-disable-next-line @rushstack/no-new-null
 		versionId: string | null,
 		count: number,
 		scenarioName?: string,
@@ -276,6 +282,7 @@ class BlobOnlyStorage implements IDocumentStorageService {
 	}
 
 	/* eslint-disable @typescript-eslint/unbound-method */
+	// eslint-disable-next-line @rushstack/no-new-null
 	public getSnapshotTree: () => Promise<ISnapshotTree | null> = this.notCalled;
 	public getSnapshot: () => Promise<ISnapshot> = this.notCalled;
 	public getVersions: () => Promise<IVersion[]> = this.notCalled;
@@ -289,9 +296,9 @@ class BlobOnlyStorage implements IDocumentStorageService {
 		try {
 			// some browsers may not populate stack unless exception is thrown
 			throw new Error("BlobOnlyStorage not implemented method used");
-		} catch (err) {
-			this.logger.sendTelemetryEvent({ eventName: "BlobOnlyStorageWrongCall" }, err);
-			throw err;
+		} catch (error) {
+			this.logger.sendTelemetryEvent({ eventName: "BlobOnlyStorageWrongCall" }, error);
+			throw error;
 		}
 	}
 }
@@ -321,8 +328,8 @@ async function getBlobContentsFromTreeCore(
 	blobs: ISerializableBlobContents,
 	storage: Pick<IDocumentStorageService, "readBlob">,
 	root = true,
-) {
-	const treePs: Promise<any>[] = [];
+): Promise<unknown[]> {
+	const treePs: Promise<unknown>[] = [];
 	for (const [key, subTree] of Object.entries(tree.trees)) {
 		if (root && key === blobsTreeName) {
 			treePs.push(getBlobManagerTreeFromTree(subTree, blobs, storage));
@@ -343,7 +350,7 @@ async function getBlobManagerTreeFromTree(
 	tree: ISnapshotTree,
 	blobs: ISerializableBlobContents,
 	storage: Pick<IDocumentStorageService, "readBlob">,
-) {
+): Promise<void> {
 	const id = tree.blobs[redirectTableBlobName];
 	const blob = await storage.readBlob(id);
 	// ArrayBufferLike will not survive JSON.stringify()
@@ -365,7 +372,7 @@ function getBlobContentsFromTreeWithBlobContentsCore(
 	tree: ISnapshotTreeWithBlobContents,
 	blobs: ISerializableBlobContents,
 	root = true,
-) {
+): void {
 	for (const [key, subTree] of Object.entries(tree.trees)) {
 		if (root && key === blobsTreeName) {
 			getBlobManagerTreeFromTreeWithBlobContents(subTree, blobs);
@@ -385,7 +392,7 @@ function getBlobContentsFromTreeWithBlobContentsCore(
 function getBlobManagerTreeFromTreeWithBlobContents(
 	tree: ISnapshotTreeWithBlobContents,
 	blobs: ISerializableBlobContents,
-) {
+): void {
 	const id = tree.blobs[redirectTableBlobName];
 	const blob = tree.blobsContents?.[id];
 	assert(blob !== undefined, 0x70f /* Blob must be present in blobsContents */);

package/src/contracts.ts

@@ -52,19 +52,29 @@ export interface IConnectionManager {
 
 	readonly clientId: string | undefined;
 
-	/** The queue of outbound delta messages */
+	/**
+	 * The queue of outbound delta messages
+	 */
 	readonly outbound: IDeltaQueue<IDocumentMessage[]>;
 
-	/** Details of client */
+	/**
+	 * Details of client
+	 */
 	readonly clientDetails: IClientDetails;
 
-	/** Protocol version being used to communicate with the service */
+	/**
+	 * Protocol version being used to communicate with the service
+	 */
 	readonly version: string;
 
-	/** Max message size allowed to the delta manager */
+	/**
+	 * Max message size allowed to the delta manager
+	 */
 	readonly maxMessageSize: number;
 
-	/** Service configuration provided by the service. */
+	/**
+	 * Service configuration provided by the service.
+	 */
 	readonly serviceConfiguration: IClientConfiguration | undefined;
 
 	readonly readOnlyInfo: ReadOnlyInfo;
@@ -149,7 +159,7 @@ export interface IConnectionManagerFactoryArgs {
 	 * Called by connection manager whenever critical error happens and container should be closed.
 	 * Expects dispose() call in response to this call.
 	 */
-	readonly closeHandler: (error?: any) => void;
+	readonly closeHandler: (error?: IErrorBase) => void;
 
 	/**
 	 * Called whenever connection to relay service is lost.
@@ -197,14 +207,15 @@ export interface IConnectionManagerFactoryArgs {
 }
 
 /**
- *
+ * Gets the name of the Fluid package.
  * @param codeDetails- - Data structure used to describe the code to load on the Fluid document
- * @returns The name of the Fluid package
  */
 export const getPackageName = (
 	codeDetails: IFluidCodeDetails | undefined,
 ): IContainerPackageInfo => {
-	let containerPackageName;
+	// TODO: use a real type
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	let containerPackageName: any;
 	if (codeDetails && "name" in codeDetails) {
 		containerPackageName = codeDetails;
 	} else if (isFluidPackage(codeDetails?.package)) {
@@ -212,5 +223,6 @@ export const getPackageName = (
 	} else {
 		containerPackageName = codeDetails?.package;
 	}
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 	return { name: containerPackageName };
 };

package/src/debugLogger.ts

@@ -45,7 +45,7 @@ export class DebugLogger implements ITelemetryBaseLogger {
 		// Create one for errors that is always enabled
 		// It can be silenced by replacing console.error if the debug namespace is not enabled.
 		const debugErr = registerDebug(namespace);
-		debugErr.log = function (...args) {
+		debugErr.log = function (...args: unknown[]): void {
 			if (debug.enabled === true) {
 				// if the namespace is enabled, just use the default logger
 				registerDebug.log(...args);
@@ -81,9 +81,9 @@ export class DebugLogger implements ITelemetryBaseLogger {
 
 		// Use debug's coloring schema for base of the event
 		const index = event.eventName.lastIndexOf(eventNamespaceSeparator);
-		const name = event.eventName.substring(index + 1);
+		const name = event.eventName.slice(Math.max(0, index + 1));
 		if (index > 0) {
-			logger = logger.extend(event.eventName.substring(0, index));
+			logger = logger.extend(event.eventName.slice(0, index));
 		}
 		newEvent.eventName = undefined;
 
@@ -100,7 +100,7 @@ export class DebugLogger implements ITelemetryBaseLogger {
 		let payload: string;
 		try {
 			payload = JSON.stringify(newEvent);
-		} catch (error) {
+		} catch {
 			newEvent.error = undefined;
 			payload = JSON.stringify(newEvent);
 		}

package/src/deltaManager.ts

@@ -8,6 +8,8 @@ import {
 	IDeltaManager,
 	IDeltaManagerEvents,
 	IDeltaQueue,
+	type IDeltaSender,
+	type ReadOnlyInfo,
 } from "@fluidframework/container-definitions/internal";
 import {
 	IEventProvider,
@@ -25,6 +27,8 @@ import {
 	MessageType,
 	ISequencedDocumentMessage,
 	ISignalMessage,
+	type IClientDetails,
+	type IClientConfiguration,
 } from "@fluidframework/driver-definitions/internal";
 import {
 	MessageType2,
@@ -113,10 +117,12 @@ function isClientMessage(message: ISequencedDocumentMessage | IDocumentMessage):
 		case MessageType.Reject:
 		case MessageType.NoOp:
 		case MessageType2.Accept:
-		case MessageType.Summarize:
+		case MessageType.Summarize: {
 			return true;
-		default:
+		}
+		default: {
 			return false;
+		}
 	}
 }
 
@@ -159,11 +165,11 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 		return this._active();
 	}
 
-	public get disposed() {
+	public get disposed(): boolean {
 		return this._closed;
 	}
 
-	public get IDeltaSender() {
+	public get IDeltaSender(): IDeltaSender {
 		return this;
 	}
 
@@ -188,9 +194,13 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 	private lastProcessedSequenceNumber: number = 0;
 	private lastProcessedMessage: ISequencedDocumentMessage | undefined;
 
-	/** count number of noops sent by the client which may not be acked */
+	/**
+	 * Count the number of noops sent by the client which may not be acked
+	 */
 	private noOpCount: number = 0;
-	/** Track clientSequenceNumber of the last op */
+	/**
+	 * Track clientSequenceNumber of the last op
+	 */
 	private lastClientSequenceNumber: number = 0;
 
 	/**
@@ -242,11 +252,11 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 		return this.lastProcessedSequenceNumber;
 	}
 
-	public get lastMessage() {
+	public get lastMessage(): ISequencedDocumentMessage | undefined {
 		return this.lastProcessedMessage;
 	}
 
-	public get lastKnownSeqNumber() {
+	public get lastKnownSeqNumber(): number {
 		return this.lastObservedSeqNumber;
 	}
 
@@ -258,7 +268,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 	 * Tells if  current connection has checkpoint information.
 	 * I.e. we know how far behind the client was at the time of establishing connection
 	 */
-	public get hasCheckpointSequenceNumber() {
+	public get hasCheckpointSequenceNumber(): boolean {
 		// Valid to be called only if we have active connection.
 		assert(this.connectionManager.connected, 0x0df /* "Missing active connection" */);
 		return this._checkpointSequenceNumber !== undefined;
@@ -268,19 +278,19 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 	public get maxMessageSize(): number {
 		return this.connectionManager.maxMessageSize;
 	}
-	public get version() {
+	public get version(): string {
 		return this.connectionManager.version;
 	}
-	public get serviceConfiguration() {
+	public get serviceConfiguration(): IClientConfiguration | undefined {
 		return this.connectionManager.serviceConfiguration;
 	}
-	public get outbound() {
+	public get outbound(): IDeltaQueue<IDocumentMessage[]> {
 		return this.connectionManager.outbound;
 	}
-	public get readOnlyInfo() {
+	public get readOnlyInfo(): ReadOnlyInfo {
 		return this.connectionManager.readOnlyInfo;
 	}
-	public get clientDetails() {
+	public get clientDetails(): IClientDetails {
 		return this.connectionManager.clientDetails;
 	}
 
@@ -288,10 +298,10 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 		type: MessageType,
 		contents?: string,
 		batch = false,
-		metadata?: any,
+		metadata?: unknown,
 		compression?: string,
 		referenceSequenceNumber?: number,
-	) {
+	): number {
 		// Back-compat ADO:3455
 		const backCompatRefSeqNum = referenceSequenceNumber ?? this.lastProcessedSequenceNumber;
 		const messagePartial: Omit<IDocumentMessage, "clientSequenceNumber"> = {
@@ -330,11 +340,11 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 		return message.clientSequenceNumber;
 	}
 
-	public submitSignal(content: string, targetClientId?: string) {
+	public submitSignal(content: string, targetClientId?: string): void {
 		return this.connectionManager.submitSignal(content, targetClientId);
 	}
 
-	public flush() {
+	public flush(): void {
 		const batch = this.messageBuffer;
 		if (batch.length === 0) {
 			return;
@@ -381,7 +391,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 	 * we stop processing ops that results in no processing join op and thus moving to connected state)
 	 * @param event - Event to log.
 	 */
-	public logConnectionIssue(event: ITelemetryErrorEventExt) {
+	public logConnectionIssue(event: ITelemetryErrorEventExt): void {
 		assert(this.connectionManager.connected, 0x238 /* "called only in connected state" */);
 
 		const pendingSorted = this.pending.sort((a, b) => a.sequenceNumber - b.sequenceNumber);
@@ -436,7 +446,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 			},
 			reconnectionDelayHandler: (delayMs: number, error: unknown) =>
 				this.emitDelayInfo(this.deltaStreamDelayId, delayMs, error),
-			closeHandler: (error: any) => this.close(error),
+			closeHandler: (error: ICriticalContainerError | undefined) => this.close(error),
 			disconnectHandler: (reason: IConnectionStateChangeReason) =>
 				this.disconnectHandler(reason),
 			connectHandler: (connection: IConnectionDetailsInternal) =>
@@ -489,15 +499,15 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 		// - inbound & inboundSignal are resumed in attachOpHandler() when we have handler setup
 	}
 
-	private cancelEstablishingConnection(reason: IConnectionStateChangeReason) {
+	private cancelEstablishingConnection(reason: IConnectionStateChangeReason): void {
 		this.emit("cancelEstablishingConnection", reason);
 	}
 
-	private establishingConnection(reason: IConnectionStateChangeReason) {
+	private establishingConnection(reason: IConnectionStateChangeReason): void {
 		this.emit("establishingConnection", reason);
 	}
 
-	private connectHandler(connection: IConnectionDetailsInternal) {
+	private connectHandler(connection: IConnectionDetailsInternal): void {
 		this.refreshDelayInfo(this.deltaStreamDelayId);
 
 		const props = this.connectionManager.connectionVerboseProps;
@@ -526,9 +536,9 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 		this.emit(
 			"connect",
 			connection,
-			checkpointSequenceNumber !== undefined
-				? this.lastObservedSeqNumber - this.lastSequenceNumber
-				: undefined,
+			checkpointSequenceNumber === undefined
+				? undefined
+				: this.lastObservedSeqNumber - this.lastSequenceNumber,
 		);
 
 		// If we got some initial ops, then we know the gap and call above fetched ops to fill it.
@@ -558,7 +568,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 		handler: IDeltaHandlerStrategy,
 		prefetchType: "cached" | "all" | "none" = "none",
 		lastProcessedSequenceNumber: number = snapshotSequenceNumber,
-	) {
+	): Promise<void> {
 		this.initSequenceNumber = snapshotSequenceNumber;
 		this.lastProcessedSequenceNumber = lastProcessedSequenceNumber;
 		this.minSequenceNumber = minSequenceNumber;
@@ -572,7 +582,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 		);
 		this.handler = handler;
 		// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-		assert(!!(this.handler as any), 0x0e3 /* "Newly set op handler is null/undefined!" */);
+		assert(!!this.handler, 0x0e3 /* "Newly set op handler is null/undefined!" */);
 
 		// There should be no pending fetch!
 		// This API is called right after attachOpHandler by Container.load().
@@ -612,7 +622,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 		);
 	}
 
-	public connect(args: IConnectionArgs) {
+	public connect(args: IConnectionArgs): void {
 		const fetchOpsFromStorage = args.fetchOpsFromStorage ?? true;
 		logIfFalse(
 			this.handler !== undefined || !fetchOpsFromStorage,
@@ -643,7 +653,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 		fetchReason: string,
 		callback: (messages: ISequencedDocumentMessage[]) => void,
 		cacheOnly: boolean,
-	) {
+	): Promise<void> {
 		const docService = this.serviceProvider();
 		if (docService === undefined) {
 			throw new Error("Delta manager is not attached");
@@ -655,7 +665,14 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 
 		let cancelFetch: (op: ISequencedDocumentMessage) => boolean;
 
-		if (to !== undefined) {
+		if (to === undefined) {
+			// Unbound requests are made to proactively fetch ops, but also get up to date in cases where socket
+			// is silent (and connection is "read", thus we might not have any data on how far client is behind).
+			// Once we have any op coming in from socket, we can cancel it as it's not needed any more.
+			// That said, if we have socket connection, make sure we got ops up to checkpointSequenceNumber!
+			cancelFetch = (op: ISequencedDocumentMessage): boolean =>
+				op.sequenceNumber >= this.lastObservedSeqNumber;
+		} else {
 			const lastExpectedOp = to - 1; // make it inclusive!
 
 			// It is possible that due to asynchrony (including await above), required ops were already
@@ -677,20 +694,14 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 			// detected gap, this gap can't be filled in later on through websocket).
 			// And in practice that does look like the case. The place where this code gets hit is if we lost
 			// connection and reconnected (likely to another box), and new socket's initial ops contains these ops.
-			cancelFetch = (op: ISequencedDocumentMessage) => op.sequenceNumber >= lastExpectedOp;
-		} else {
-			// Unbound requests are made to proactively fetch ops, but also get up to date in cases where socket
-			// is silent (and connection is "read", thus we might not have any data on how far client is behind).
-			// Once we have any op coming in from socket, we can cancel it as it's not needed any more.
-			// That said, if we have socket connection, make sure we got ops up to checkpointSequenceNumber!
-			cancelFetch = (op: ISequencedDocumentMessage) =>
-				op.sequenceNumber >= this.lastObservedSeqNumber;
+			cancelFetch = (op: ISequencedDocumentMessage): boolean =>
+				op.sequenceNumber >= lastExpectedOp;
 		}
 
 		const controller = new AbortController();
 		let opsFromFetch = false;
 
-		const opListener = (op: ISequencedDocumentMessage) => {
+		const opListener = (op: ISequencedDocumentMessage): void => {
 			assert(op.sequenceNumber === this.lastQueuedSequenceNumber, 0x23a /* "seq#'s" */);
 			// Ops that are coming from this request should not cancel itself.
 			// This is useless for known ranges (to is defined) as it means request is over either way.
@@ -704,8 +715,9 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 		try {
 			this._inbound.on("push", opListener);
 			assert(this.closeAbortController.signal.onabort === null, 0x1e8 /* "reentrancy" */);
-			this.closeAbortController.signal.onabort = () =>
-				controller.abort(this.closeAbortController.signal.reason);
+			this.closeAbortController.signal.addEventListener("abort", () =>
+				controller.abort(this.closeAbortController.signal.reason),
+			);
 
 			const stream = this.deltaStorage.fetchMessages(
 				from, // inclusive
@@ -733,9 +745,11 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 				this.logger.sendTelemetryEvent({
 					eventName: "DeltaManager_GetDeltasAborted",
 					fetchReason,
+					// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 					reason: controller.signal.reason,
 				});
 			}
+			// eslint-disable-next-line unicorn/no-null, unicorn/prefer-add-event-listener
 			this.closeAbortController.signal.onabort = null;
 			this._inbound.off("push", opListener);
 			assert(!opsFromFetch, 0x289 /* "logic error" */);
@@ -789,7 +803,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 		this.removeAllListeners();
 	}
 
-	private clearQueues() {
+	private clearQueues(): void {
 		this.closeAbortController.abort("DeltaManager is closed");
 
 		this._inbound.clear();
@@ -804,14 +818,14 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 		this.pending = [];
 	}
 
-	public refreshDelayInfo(id: string) {
+	public refreshDelayInfo(id: string): void {
 		this.throttlingIdSet.delete(id);
 		if (this.throttlingIdSet.size === 0) {
 			this.timeTillThrottling = 0;
 		}
 	}
 
-	private disconnectHandler(reason: IConnectionStateChangeReason) {
+	private disconnectHandler(reason: IConnectionStateChangeReason): void {
 		this.messageBuffer.length = 0;
 		this.emit("disconnect", reason.text, reason.error);
 	}
@@ -822,7 +836,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 	 * @param delayMs - Duration of the delay
 	 * @param error - error object indicating the throttling
 	 */
-	public emitDelayInfo(id: string, delayMs: number, error: unknown) {
+	public emitDelayInfo(id: string, delayMs: number, error: unknown): void {
 		const timeNow = Date.now();
 		this.throttlingIdSet.add(id);
 		if (delayMs > 0 && timeNow + delayMs > this.timeTillThrottling) {
@@ -844,7 +858,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 	// reuse.
 	// Also payload goes to telemetry, so no content or anything else that shouldn't be logged for privacy reasons
 	// Note: It's possible for a duplicate op to be broadcasted and have everything the same except the timestamp.
-	private comparableMessagePayload(m: ISequencedDocumentMessage) {
+	private comparableMessagePayload(m: ISequencedDocumentMessage): string {
 		return `${m.clientId}-${m.type}-${m.minimumSequenceNumber}-${m.referenceSequenceNumber}-${m.timestamp}`;
 	}
 
@@ -859,7 +873,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 			// and thus faster than attachOpHandler() is called
 			// this.lastProcessedSequenceNumber is still zero, so we can't rely on this.fetchMissingDeltas()
 			// to do the right thing.
-			this.pending = this.pending.concat(messages);
+			this.pending = [...this.pending, ...messages];
 			return;
 		}
 
@@ -937,7 +951,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 					length: messages.length,
 					fetchReason: this.fetchReason,
 					duplicate: duplicate > 0 ? duplicate : undefined,
-					initialGap: initialGap !== 0 ? initialGap : undefined,
+					initialGap: initialGap === 0 ? undefined : initialGap,
 					gap: gap > 0 ? gap : undefined,
 					firstMissing,
 					dmInitialSeqNumber: this.initialSequenceNumber,
@@ -985,13 +999,13 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 						this.close(error);
 					}
 				}
-			} else if (message.sequenceNumber !== this.lastQueuedSequenceNumber + 1) {
-				this.pending.push(message);
-				this.fetchMissingDeltas(reason, message.sequenceNumber);
-			} else {
+			} else if (message.sequenceNumber === this.lastQueuedSequenceNumber + 1) {
 				this.lastQueuedSequenceNumber = message.sequenceNumber;
 				this.previouslyProcessedMessage = message;
 				this._inbound.push(message);
+			} else {
+				this.pending.push(message);
+				this.fetchMissingDeltas(reason, message.sequenceNumber);
 			}
 		}
 
@@ -1103,7 +1117,7 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 	/**
 	 * Retrieves the missing deltas between the given sequence numbers
 	 */
-	private fetchMissingDeltas(reasonArg: string, to?: number) {
+	private fetchMissingDeltas(reasonArg: string, to?: number): void {
 		this.fetchMissingDeltasCore(reasonArg, false /* cacheOnly */, to).catch((error) => {
 			this.logger.sendErrorEvent({ eventName: "fetchMissingDeltasException" }, error);
 		});
@@ -1112,7 +1126,11 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 	/**
 	 * Retrieves the missing deltas between the given sequence numbers
 	 */
-	private async fetchMissingDeltasCore(reason: string, cacheOnly: boolean, to?: number) {
+	private async fetchMissingDeltasCore(
+		reason: string,
+		cacheOnly: boolean,
+		to?: number,
+	): Promise<void> {
 		// Exit out early if we're already fetching deltas
 		if (this.fetchReason !== undefined) {
 			return;
@@ -1199,13 +1217,14 @@ export class DeltaManager<TConnectionManager extends IConnectionManager>
 			// and thus can leverage that to trigger recovery. But this is not going to solve all the problems
 			// (the other 50%), and thus these errors below should be looked at even if code below results in
 			// recovery.
+			// eslint-disable-next-line unicorn/no-lonely-if -- Docs make more sense like this
 			if (this.lastQueuedSequenceNumber < this.lastObservedSeqNumber) {
 				this.fetchMissingDeltas("OpsBehind");
 			}
 		}
 	}
 
-	private updateLatestKnownOpSeqNumber(seq: number) {
+	private updateLatestKnownOpSeqNumber(seq: number): void {
 		if (this.lastObservedSeqNumber < seq) {
 			this.lastObservedSeqNumber = seq;
 		}