@fluidframework/container-loader 2.0.0-internal.1.1.3 → 2.0.0-internal.1.2.0

package/src/catchUpMonitor.ts

@@ -3,34 +3,29 @@
  * Licensed under the MIT License.
  */
 
-import { IDisposable, IEvent } from "@fluidframework/common-definitions";
-import { assert, TypedEventEmitter } from "@fluidframework/common-utils";
+import { IDisposable } from "@fluidframework/common-definitions";
+import { assert } from "@fluidframework/common-utils";
 import { IDeltaManager } from "@fluidframework/container-definitions";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 
-/** @see ICatchUpMonitor for usage */
+/** @see CatchUpMonitor for usage */
 type CaughtUpListener = () => void;
 
-/** @see ICatchUpMonitor for usage */
-export interface ICatchUpMonitorEvents extends IEvent {
-    (event: "caughtUp", listener: CaughtUpListener): void;
-}
-
 /** Monitor that emits an event when a Container has caught up to a given point in the op stream */
-export interface ICatchUpMonitor extends TypedEventEmitter<ICatchUpMonitorEvents>, IDisposable { }
+export type ICatchUpMonitor = IDisposable;
 
 /**
  * Monitors a Container's DeltaManager, notifying listeners when all ops have been processed
  * that were known at the time the monitor was created.
  */
-export class CatchUpMonitor extends TypedEventEmitter<ICatchUpMonitorEvents> implements ICatchUpMonitor {
+export class CatchUpMonitor implements ICatchUpMonitor {
     private readonly targetSeqNumber: number;
     private caughtUp: boolean = false;
 
     private readonly opHandler = (message: Pick<ISequencedDocumentMessage, "sequenceNumber">) => {
         if (!this.caughtUp && message.sequenceNumber >= this.targetSeqNumber) {
             this.caughtUp = true;
-            this.emit("caughtUp");
+            this.listener();
         }
     };
 
@@ -39,9 +34,8 @@ export class CatchUpMonitor extends TypedEventEmitter<ICatchUpMonitorEvents> imp
      */
     constructor(
         private readonly deltaManager: IDeltaManager<any, any>,
+        private readonly listener: CaughtUpListener,
     ) {
-        super();
-
         this.targetSeqNumber = this.deltaManager.lastKnownSeqNumber;
 
         assert(this.targetSeqNumber >= this.deltaManager.lastSequenceNumber,
@@ -51,16 +45,6 @@ export class CatchUpMonitor extends TypedEventEmitter<ICatchUpMonitorEvents> imp
 
         // Simulate the last processed op to set caughtUp in case we already are
         this.opHandler({ sequenceNumber: this.deltaManager.lastSequenceNumber });
-
-        // If a listener is added after we are already caught up, notify that new listener immediately
-        this.on("newListener", (event: string, listener) => {
-            if (event === "caughtUp") {
-                const caughtUpListener = listener as CaughtUpListener;
-                if (this.caughtUp) {
-                    caughtUpListener();
-                }
-            }
-        });
     }
 
     public disposed: boolean = false;
@@ -70,30 +54,6 @@ export class CatchUpMonitor extends TypedEventEmitter<ICatchUpMonitorEvents> imp
         }
         this.disposed = true;
 
-        this.removeAllListeners();
         this.deltaManager.off("op", this.opHandler);
     }
 }
-
-/** Monitor that always notifies listeners immediately */
-export class ImmediateCatchUpMonitor extends TypedEventEmitter<ICatchUpMonitorEvents> implements ICatchUpMonitor {
-    constructor() {
-        super();
-        this.on("newListener", (event: string, listener) => {
-            if (event === "caughtUp") {
-                const caughtUpListener = listener as CaughtUpListener;
-                caughtUpListener();
-            }
-        });
-    }
-
-    public disposed: boolean = false;
-    public dispose() {
-        if (this.disposed) {
-            return;
-        }
-        this.disposed = true;
-
-        this.removeAllListeners();
-    }
-}

package/src/collabWindowTracker.ts

@@ -5,7 +5,7 @@
 
 import { assert, Timer } from "@fluidframework/common-utils";
 import { ISequencedDocumentMessage, MessageType } from "@fluidframework/protocol-definitions";
-import { isRuntimeMessage } from "@fluidframework/driver-utils";
+import { isRuntimeMessage, MessageType2 } from "@fluidframework/driver-utils";
 
 const defaultNoopTimeFrequency = 2000;
 const defaultNoopCountFrequency = 50;
@@ -34,7 +34,7 @@ export class CollabWindowTracker {
     private readonly timer: Timer | undefined;
 
     constructor(
-        private readonly submit: (type: MessageType, contents: any) => void,
+        private readonly submit: (type: MessageType) => void,
         NoopTimeFrequency: number = defaultNoopTimeFrequency,
         private readonly NoopCountFrequency: number = defaultNoopCountFrequency,
     ) {
@@ -93,7 +93,8 @@ export class CollabWindowTracker {
 
     private submitNoop(immediate: boolean) {
         // Anything other than null is immediate noop
-        this.submit(MessageType.NoOp, immediate ? "" : null);
+        // ADO:1385: Remove cast and use MessageType once definition changes propagate
+        this.submit(immediate ? (MessageType2.Accept as unknown as MessageType) : MessageType.NoOp);
         assert(this.opsCountSinceNoop === 0,
             0x243 /* "stopSequenceNumberUpdate should be called as result of sending any op!" */);
     }

package/src/connectionManager.ts

@@ -31,7 +31,7 @@ import {
     waitForConnectedState,
     DeltaStreamConnectionForbiddenError,
     logNetworkFailure,
-    // isRuntimeMessage,
+    isRuntimeMessage,
 } from "@fluidframework/driver-utils";
 import {
     ConnectionMode,
@@ -168,7 +168,7 @@ export class ConnectionManager implements IConnectionManager {
     private clientSequenceNumber = 0;
     private clientSequenceNumberObserved = 0;
     /** Counts the number of noops sent by the client which may not be acked. */
-    private trailingNoopCount = 0;
+    private localOpsToIgnore = 0;
 
     /** track clientId used last time when we sent any ops */
     private lastSubmittedClientId: string | undefined;
@@ -234,20 +234,18 @@ export class ConnectionManager implements IConnectionManager {
      * about current or last connection (if there is no connection at the moment)
     */
     public get connectionProps(): ITelemetryProperties {
-        if (this.connection !== undefined) {
-            return this._connectionProps;
-        } else {
-            return {
+        return this.connection !== undefined
+            ? this._connectionProps
+            : {
                 ...this._connectionProps,
                 // Report how many ops this client sent in last disconnected session
                 sentOps: this.clientSequenceNumber,
             };
-        }
     }
 
     public shouldJoinWrite(): boolean {
         // We don't have to wait for ack for topmost NoOps. So subtract those.
-        return this.clientSequenceNumberObserved < (this.clientSequenceNumber - this.trailingNoopCount);
+        return this.clientSequenceNumberObserved < (this.clientSequenceNumber - this.localOpsToIgnore);
     }
 
     /**
@@ -819,10 +817,10 @@ export class ConnectionManager implements IConnectionManager {
             this.clientSequenceNumberObserved = 0;
         }
 
-        if (message.type === MessageType.NoOp) {
-            this.trailingNoopCount++;
+        if (!isRuntimeMessage(message)) {
+            this.localOpsToIgnore++;
         } else {
-            this.trailingNoopCount = 0;
+            this.localOpsToIgnore = 0;
         }
 
         return {