@fluidframework/sequence 2.0.0-rc.4.0.5 → 2.0.0-rc.5.0.0

package/dist/sequence.js

@@ -10,11 +10,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resetReentrancyLogCounter = exports.SharedSegmentSequence = void 0;
 const client_utils_1 = require("@fluid-internal/client-utils");
 const internal_1 = require("@fluidframework/core-utils/internal");
-const internal_2 = require("@fluidframework/merge-tree/internal");
-const protocol_definitions_1 = require("@fluidframework/protocol-definitions");
-const internal_3 = require("@fluidframework/runtime-utils/internal");
-const internal_4 = require("@fluidframework/shared-object-base/internal");
-const internal_5 = require("@fluidframework/telemetry-utils/internal");
+const internal_2 = require("@fluidframework/driver-definitions/internal");
+const internal_3 = require("@fluidframework/merge-tree/internal");
+const internal_4 = require("@fluidframework/runtime-utils/internal");
+const internal_5 = require("@fluidframework/shared-object-base/internal");
+const internal_6 = require("@fluidframework/telemetry-utils/internal");
 const double_ended_queue_1 = __importDefault(require("double-ended-queue"));
 const intervalCollection_js_1 = require("./intervalCollection.js");
 const intervalCollectionMap_js_1 = require("./intervalCollectionMap.js");
@@ -24,15 +24,20 @@ const contentPath = "content";
 /**
  * @alpha
  */
-class SharedSegmentSequence extends internal_4.SharedObject {
+class SharedSegmentSequence extends internal_5.SharedObject {
+    /**
+     * This promise is always immediately resolved, and awaiting it has no effect.
+     * @deprecated SharedSegmentSequence no longer supports partial loading.
+     * References to this promise may safely be deleted without affecting behavior.
+     */
     get loaded() {
-        return this.loadedDeferred.promise;
+        return Promise.resolve();
     }
     static createOpsFromDelta(event) {
         const ops = [];
         for (const r of event.ranges) {
             switch (event.deltaOperation) {
-                case internal_2.MergeTreeDeltaType.ANNOTATE: {
+                case internal_3.MergeTreeDeltaType.ANNOTATE: {
                     const lastAnnotate = ops[ops.length - 1];
                     const props = {};
                     for (const key of Object.keys(r.propertyDeltas)) {
@@ -40,29 +45,29 @@ class SharedSegmentSequence extends internal_4.SharedObject {
                     }
                     if (lastAnnotate &&
                         lastAnnotate.pos2 === r.position &&
-                        (0, internal_2.matchProperties)(lastAnnotate.props, props)) {
+                        (0, internal_3.matchProperties)(lastAnnotate.props, props)) {
                         lastAnnotate.pos2 += r.segment.cachedLength;
                     }
                     else {
-                        ops.push((0, internal_2.createAnnotateRangeOp)(r.position, r.position + r.segment.cachedLength, props));
+                        ops.push((0, internal_3.createAnnotateRangeOp)(r.position, r.position + r.segment.cachedLength, props));
                     }
                     break;
                 }
-                case internal_2.MergeTreeDeltaType.INSERT:
-                    ops.push((0, internal_2.createInsertOp)(r.position, r.segment.clone().toJSONObject()));
+                case internal_3.MergeTreeDeltaType.INSERT:
+                    ops.push((0, internal_3.createInsertOp)(r.position, r.segment.clone().toJSONObject()));
                     break;
-                case internal_2.MergeTreeDeltaType.REMOVE: {
+                case internal_3.MergeTreeDeltaType.REMOVE: {
                     const lastRem = ops[ops.length - 1];
                     if (lastRem?.pos1 === r.position) {
                         (0, internal_1.assert)(lastRem.pos2 !== undefined, 0x3ff /* pos2 should not be undefined here */);
                         lastRem.pos2 += r.segment.cachedLength;
                     }
                     else {
-                        ops.push((0, internal_2.createRemoveRangeOp)(r.position, r.position + r.segment.cachedLength));
+                        ops.push((0, internal_3.createRemoveRangeOp)(r.position, r.position + r.segment.cachedLength));
                     }
                     break;
                 }
-                case internal_2.MergeTreeDeltaType.OBLITERATE: {
+                case internal_3.MergeTreeDeltaType.OBLITERATE: {
                     // eslint-disable-next-line import/no-deprecated
                     const lastRem = ops[ops.length - 1];
                     if (lastRem?.pos1 === r.position) {
@@ -70,7 +75,7 @@ class SharedSegmentSequence extends internal_4.SharedObject {
                         lastRem.pos2 += r.segment.cachedLength;
                     }
                     else {
-                        ops.push((0, internal_2.createObliterateRangeOp)(r.position, r.position + r.segment.cachedLength));
+                        ops.push((0, internal_3.createObliterateRangeOp)(r.position, r.position + r.segment.cachedLength));
                     }
                     break;
                 }
@@ -96,7 +101,6 @@ class SharedSegmentSequence extends internal_4.SharedObject {
     }
     constructor(dataStoreRuntime, id, attributes, segmentFromSpec) {
         super(id, dataStoreRuntime, attributes, "fluid_sequence_");
-        this.dataStoreRuntime = dataStoreRuntime;
         this.id = id;
         this.segmentFromSpec = segmentFromSpec;
         /**
@@ -114,14 +118,6 @@ class SharedSegmentSequence extends internal_4.SharedObject {
          * runtime).
          */
         this.inFlightRefSeqs = new double_ended_queue_1.default();
-        /** `Deferred` that triggers once the object is loaded */
-        this.loadedDeferred = new internal_1.Deferred();
-        // cache out going ops created when partial loading
-        // eslint-disable-next-line import/no-deprecated
-        this.loadedDeferredOutgoingOps = [];
-        // cache incoming ops that arrive when partial loading
-        this.deferIncomingOps = true;
-        this.loadedDeferredIncomingOps = [];
         this.messagesSinceMSNChange = [];
         const getMinInFlightRefSeq = () => this.inFlightRefSeqs.get(0);
         this.guardReentrancy =
@@ -130,14 +126,11 @@ class SharedSegmentSequence extends internal_4.SharedObject {
                 : createReentrancyDetector((depth) => {
                     if (totalReentrancyLogs > 0) {
                         totalReentrancyLogs--;
-                        this.logger.sendTelemetryEvent({ eventName: "LocalOpReentry", depth }, new internal_5.LoggingError(reentrancyErrorMessage));
+                        this.logger.sendTelemetryEvent({ eventName: "LocalOpReentry", depth }, new internal_6.LoggingError(reentrancyErrorMessage));
                     }
                 });
-        this.loadedDeferred.promise.catch((error) => {
-            this.logger.sendErrorEvent({ eventName: "SequenceLoadFailed" }, error);
-        });
         // eslint-disable-next-line import/no-deprecated
-        this.client = new internal_2.Client(segmentFromSpec, (0, internal_5.createChildLogger)({
+        this.client = new internal_3.Client(segmentFromSpec, (0, internal_6.createChildLogger)({
             logger: this.logger,
             namespace: "SharedSegmentSequence.MergeTreeClient",
         }), dataStoreRuntime.options, getMinInFlightRefSeq);
@@ -159,62 +152,25 @@ class SharedSegmentSequence extends internal_4.SharedObject {
             this.submitLocalMessage(op, localOpMetadata);
         }, new intervalCollection_js_1.SequenceIntervalCollectionValueType(), dataStoreRuntime.options);
     }
-    /**
-     * @param start - The inclusive start of the range to remove
-     * @param end - The exclusive end of the range to remove
-     */
     removeRange(start, end) {
         this.guardReentrancy(() => this.client.removeRangeLocal(start, end));
     }
-    /**
-     * Obliterate is similar to remove, but differs in that segments concurrently
-     * inserted into an obliterated range will also be removed
-     *
-     * @param start - The inclusive start of the range to obliterate
-     * @param end - The exclusive end of the range to obliterate
-     */
     obliterateRange(start, end) {
         this.guardReentrancy(() => this.client.obliterateRangeLocal(start, end));
     }
-    /**
-     * @deprecated The ability to create group ops will be removed in an upcoming
-     * release, as group ops are redundant with the native batching capabilities
-     * of the runtime
-     */
     // eslint-disable-next-line import/no-deprecated
     groupOperation(groupOp) {
         this.guardReentrancy(() => this.client.localTransaction(groupOp));
     }
-    /**
-     * Finds the segment information (i.e. segment + offset) corresponding to a character position in the SharedString.
-     * If the position is past the end of the string, `segment` and `offset` on the returned object may be undefined.
-     * @param pos - Character position (index) into the current local view of the SharedString.
-     */
     getContainingSegment(pos) {
         return this.client.getContainingSegment(pos);
     }
-    /**
-     * Returns the length of the current sequence for the client
-     */
     getLength() {
         return this.client.getLength();
     }
-    /**
-     * Returns the current position of a segment, and -1 if the segment
-     * does not exist in this sequence
-     * @param segment - The segment to get the position of
-     */
     getPosition(segment) {
         return this.client.getPosition(segment);
     }
-    /**
-     * Annotates the range with the provided properties
-     *
-     * @param start - The inclusive start position of the range to annotate
-     * @param end - The exclusive end position of the range to annotate
-     * @param props - The properties to annotate the range with
-     *
-     */
     annotateRange(start, end, props) {
         this.guardReentrancy(() => this.client.annotateRangeLocal(start, end, props));
     }
@@ -224,48 +180,15 @@ class SharedSegmentSequence extends internal_4.SharedObject {
     getRangeExtentsOfPosition(pos) {
         return this.client.getRangeExtentsOfPosition(pos);
     }
-    /**
-     * Creates a `LocalReferencePosition` on this SharedString. If the refType does not include
-     * ReferenceType.Transient, the returned reference will be added to the localRefs on the provided segment.
-     * @param segment - Segment to add the local reference on
-     * @param offset - Offset on the segment at which to place the local reference
-     * @param refType - ReferenceType for the created local reference
-     * @param properties - PropertySet to place on the created local reference
-     */
     createLocalReferencePosition(segment, offset, refType, properties, slidingPreference, canSlideToEndpoint) {
         return this.client.createLocalReferencePosition(segment, offset, refType, properties, slidingPreference, canSlideToEndpoint);
     }
-    /**
-     * Resolves a `ReferencePosition` into a character position using this client's perspective.
-     *
-     * Reference positions that point to a character that has been removed will
-     * always return the position of the nearest non-removed character, regardless
-     * of `ReferenceType`. To handle this case specifically, one may wish
-     * to look at the segment returned by `ReferencePosition.getSegment`.
-     */
     localReferencePositionToPosition(lref) {
         return this.client.localReferencePositionToPosition(lref);
     }
-    /**
-     * Removes a `LocalReferencePosition` from this SharedString.
-     */
     removeLocalReferencePosition(lref) {
         return this.client.removeLocalReferencePosition(lref);
     }
-    /**
-     * Resolves a remote client's position against the local sequence
-     * and returns the remote client's position relative to the local
-     * sequence. The client ref seq must be above the minimum sequence number
-     * or the return value will be undefined.
-     * Generally this method is used in conjunction with signals which provide
-     * point in time values for the below parameters, and is useful for things
-     * like displaying user position. It should not be used with persisted values
-     * as persisted values will quickly become invalid as the remoteClientRefSeq
-     * moves below the minimum sequence number
-     * @param remoteClientPosition - The remote client's position to resolve
-     * @param remoteClientRefSeq - The reference sequence number of the remote client
-     * @param remoteClientId - The client id of the remote client
-     */
     resolveRemoteClientPosition(remoteClientPosition, remoteClientRefSeq, remoteClientId) {
         return this.client.resolveRemoteClientPosition(remoteClientPosition, remoteClientRefSeq, remoteClientId);
     }
@@ -274,85 +197,28 @@ class SharedSegmentSequence extends internal_4.SharedObject {
             return;
         }
         this.inFlightRefSeqs.push(this.currentRefSeq);
-        const metadata = this.client.peekPendingSegmentGroups(message.type === internal_2.MergeTreeDeltaType.GROUP ? message.ops.length : 1);
-        // if loading isn't complete, we need to cache
-        // local ops until loading is complete, and then
-        // they will be present
-        if (!this.loadedDeferred.isCompleted) {
-            this.loadedDeferredOutgoingOps.push(metadata ? [message, metadata] : message);
-        }
-        else {
-            this.submitLocalMessage(message, metadata);
-        }
+        const metadata = this.client.peekPendingSegmentGroups(message.type === internal_3.MergeTreeDeltaType.GROUP ? message.ops.length : 1);
+        this.submitLocalMessage(message, metadata);
     }
-    /**
-     * Given a position specified relative to a marker id, lookup the marker
-     * and convert the position to a character position.
-     * @param relativePos - Id of marker (may be indirect) and whether position is before or after marker.
-     */
     posFromRelativePos(relativePos) {
         return this.client.posFromRelativePos(relativePos);
     }
-    /**
-     * Walk the underlying segments of the sequence.
-     * The walked segments may extend beyond the range if the segments cross the
-     * ranges start or end boundaries.
-     *
-     * Set split range to true to ensure only segments within the range are walked.
-     *
-     * @param handler - The function to handle each segment. Traversal ends if
-     * this function returns true.
-     * @param start - Optional. The start of range walk.
-     * @param end - Optional. The end of range walk
-     * @param accum - Optional. An object that will be passed to the handler for accumulation
-     * @param splitRange - Optional. Splits boundary segments on the range boundaries
-     */
     walkSegments(handler, start, end, accum, splitRange = false) {
         this.client.walkSegments(handler, start, end, accum, splitRange);
     }
-    /**
-     * @returns The most recent sequence number which has been acked by the server and processed by this
-     * SharedSegmentSequence.
-     */
     getCurrentSeq() {
         return this.client.getCurrentSeq();
     }
-    /**
-     * Inserts a segment directly before a `ReferencePosition`.
-     * @param refPos - The reference position to insert the segment at
-     * @param segment - The segment to insert
-     */
     insertAtReferencePosition(pos, segment) {
         this.guardReentrancy(() => this.client.insertAtReferencePositionLocal(pos, segment));
     }
-    /**
-     * Inserts a segment
-     * @param start - The position to insert the segment at
-     * @param spec - The segment to inserts spec
-     */
     insertFromSpec(pos, spec) {
         const segment = this.segmentFromSpec(spec);
         this.guardReentrancy(() => this.client.insertSegmentLocal(pos, segment));
     }
-    /**
-     * Retrieves the interval collection keyed on `label`. If no such interval collection exists,
-     * creates one.
-     */
     getIntervalCollection(label) {
         return this.intervalCollections.get(label);
     }
-    /**
-     * @returns An iterable object that enumerates the IntervalCollection labels.
-     *
-     * @example
-     *
-     * ```typescript
-     * const iter = this.getIntervalCollectionKeys();
-     * for (key of iter)
-     *     const collection = this.getIntervalCollection(key);
-     *     ...
-     * ```
-     */
     getIntervalCollectionLabels() {
         return this.intervalCollections.keys();
     }
@@ -360,7 +226,7 @@ class SharedSegmentSequence extends internal_4.SharedObject {
      * {@inheritDoc @fluidframework/shared-object-base#SharedObject.summarizeCore}
      */
     summarizeCore(serializer, telemetryContext) {
-        const builder = new internal_3.SummaryTreeBuilder();
+        const builder = new internal_4.SummaryTreeBuilder();
         // conditionally write the interval collection blob
         // only if it has entries
         if (this.intervalCollections.size > 0) {
@@ -435,45 +301,35 @@ class SharedSegmentSequence extends internal_4.SharedObject {
             // this will load the header, and return a promise
             // that will resolve when the body is loaded
             // and the catchup ops are available.
-            const { catchupOpsP } = await this.client.load(this.runtime, new internal_3.ObjectStoragePartition(storage, contentPath), this.serializer);
-            // setup a promise to process the
-            // catch up ops, and finishing the loading process
-            const loadCatchUpOps = catchupOpsP
-                .then((msgs) => {
-                msgs.forEach((m) => {
-                    const collabWindow = this.client.getCollabWindow();
-                    if (m.minimumSequenceNumber < collabWindow.minSeq ||
-                        m.referenceSequenceNumber < collabWindow.minSeq ||
-                        m.sequenceNumber <= collabWindow.minSeq ||
-                        // sequenceNumber could be the same if messages are part of a grouped batch
-                        m.sequenceNumber < collabWindow.currentSeq) {
-                        throw new Error(`Invalid catchup operations in snapshot: ${JSON.stringify({
-                            op: {
-                                seq: m.sequenceNumber,
-                                minSeq: m.minimumSequenceNumber,
-                                refSeq: m.referenceSequenceNumber,
-                            },
-                            collabWindow: {
-                                seq: collabWindow.currentSeq,
-                                minSeq: collabWindow.minSeq,
-                            },
-                        })}`);
-                    }
-                    this.processMergeTreeMsg(m);
-                });
-                this.loadFinished();
-            })
-                .catch((error) => {
-                this.loadFinished(error);
+            const { catchupOpsP } = await this.client.load(this.runtime, new internal_4.ObjectStoragePartition(storage, contentPath), this.serializer);
+            // process the catch up ops, and finishing the loading process
+            (await catchupOpsP).forEach((m) => {
+                const collabWindow = this.client.getCollabWindow();
+                if (m.minimumSequenceNumber < collabWindow.minSeq ||
+                    m.referenceSequenceNumber < collabWindow.minSeq ||
+                    m.sequenceNumber <= collabWindow.minSeq ||
+                    // sequenceNumber could be the same if messages are part of a grouped batch
+                    m.sequenceNumber < collabWindow.currentSeq) {
+                    throw new Error(`Invalid catchup operations in snapshot: ${JSON.stringify({
+                        op: {
+                            seq: m.sequenceNumber,
+                            minSeq: m.minimumSequenceNumber,
+                            refSeq: m.referenceSequenceNumber,
+                        },
+                        collabWindow: {
+                            seq: collabWindow.currentSeq,
+                            minSeq: collabWindow.minSeq,
+                        },
+                    })}`);
+                }
+                this.processMergeTreeMsg(m);
             });
-            if (this.dataStoreRuntime.options.sequenceInitializeFromHeaderOnly !== true) {
-                // if we not doing partial load, await the catch up ops,
-                // and the finalization of the load
-                await loadCatchUpOps;
-            }
+            // Initialize the interval collections
+            this.initializeIntervalCollections();
         }
         catch (error) {
-            this.loadFinished(error);
+            this.logger.sendErrorEvent({ eventName: "SequenceLoadFailed" }, error);
+            throw error;
         }
     }
     /**
@@ -491,18 +347,10 @@ class SharedSegmentSequence extends internal_4.SharedObject {
             // See "handles stashed ops created on top of sequenced local ops" for one such test case.
             // assert(recordedRefSeq <= message.referenceSequenceNumber, "RefSeq mismatch");
         }
-        // if loading isn't complete, we need to cache all
-        // incoming ops to be applied after loading is complete
-        if (this.deferIncomingOps) {
-            (0, internal_1.assert)(!local, 0x072 /* "Unexpected local op when loading not finished" */);
-            this.loadedDeferredIncomingOps.push(message);
-        }
-        else {
-            (0, internal_1.assert)(message.type === protocol_definitions_1.MessageType.Operation, 0x073 /* "Sequence message not operation" */);
-            const handled = this.intervalCollections.tryProcessMessage(message.contents, local, message, localOpMetadata);
-            if (!handled) {
-                this.processMergeTreeMsg(message, local);
-            }
+        (0, internal_1.assert)(message.type === internal_2.MessageType.Operation, 0x073 /* "Sequence message not operation" */);
+        const handled = this.intervalCollections.tryProcessMessage(message.contents, local, message, localOpMetadata);
+        if (!handled) {
+            this.processMergeTreeMsg(message, local);
         }
     }
     /**
@@ -520,7 +368,7 @@ class SharedSegmentSequence extends internal_4.SharedObject {
      */
     initializeLocalCore() {
         super.initializeLocalCore();
-        this.loadFinished();
+        this.initializeIntervalCollections();
     }
     /**
      * {@inheritDoc @fluidframework/shared-object-base#SharedObjectCore.applyStashedOp}
@@ -531,8 +379,6 @@ class SharedSegmentSequence extends internal_4.SharedObject {
         }
     }
     summarizeMergeTree(serializer) {
-        // Are we fully loaded? If not, things will go south
-        (0, internal_1.assert)(this.loadedDeferred.isCompleted, 0x074 /* "Snapshot called when not fully loaded" */);
         const minSeq = this.deltaManager.minimumSequenceNumber;
         this.processMinSequenceNumberChanged(minSeq);
         this.messagesSinceMSNChange.forEach((m) => {
@@ -566,7 +412,7 @@ class SharedSegmentSequence extends internal_4.SharedObject {
                     ...message,
                     referenceSequenceNumber: stashMessage.sequenceNumber - 1,
                     // eslint-disable-next-line import/no-deprecated
-                    contents: ops.length !== 1 ? (0, internal_2.createGroupOp)(...ops) : ops[0],
+                    contents: ops.length !== 1 ? (0, internal_3.createGroupOp)(...ops) : ops[0],
                 };
             }
             this.messagesSinceMSNChange.push(stashMessage);
@@ -588,33 +434,6 @@ class SharedSegmentSequence extends internal_4.SharedObject {
             this.messagesSinceMSNChange = this.messagesSinceMSNChange.slice(index);
         }
     }
-    loadFinished(error) {
-        if (!this.loadedDeferred.isCompleted) {
-            // Initialize the interval collections
-            this.initializeIntervalCollections();
-            if (error) {
-                this.loadedDeferred.reject(error);
-                throw error;
-            }
-            else {
-                // it is important this series remains synchronous
-                // first we stop deferring incoming ops, and apply then all
-                this.deferIncomingOps = false;
-                for (const message of this.loadedDeferredIncomingOps) {
-                    this.processCore(message, false, undefined);
-                }
-                this.loadedDeferredIncomingOps.length = 0;
-                // then resolve the loaded promise
-                // and resubmit all the outstanding ops, as the snapshot
-                // is fully loaded, and all outstanding ops are applied
-                this.loadedDeferred.resolve();
-                for (const [messageContent, opMetadata] of this.loadedDeferredOutgoingOps) {
-                    this.reSubmitCore(messageContent, opMetadata);
-                }
-                this.loadedDeferredOutgoingOps.length = 0;
-            }
-        }
-    }
     initializeIntervalCollections() {
         // Listen and initialize new SharedIntervalCollections
         this.intervalCollections.eventEmitter.on("create", ({ key, previousValue }, local) => {
@@ -678,6 +497,6 @@ function resetReentrancyLogCounter() {
 exports.resetReentrancyLogCounter = resetReentrancyLogCounter;
 const reentrancyErrorMessage = "Reentrancy detected in sequence local ops";
 const ensureNoReentrancy = createReentrancyDetector(() => {
-    throw new internal_5.LoggingError(reentrancyErrorMessage);
+    throw new internal_6.LoggingError(reentrancyErrorMessage);
 });
 //# sourceMappingURL=sequence.js.map