@fluidframework/sequence 2.0.0-internal.5.4.0 → 2.0.0-internal.6.1.0

package/lib/intervalCollection.js

@@ -2,17 +2,6 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 /* eslint-disable no-bitwise */
 import { assert, TypedEventEmitter } from "@fluidframework/common-utils";
 import { UsageError } from "@fluidframework/container-utils";
@@ -32,7 +21,7 @@ function decompressInterval(interval, label) {
         end: interval[1],
         sequenceNumber: interval[2],
         intervalType: interval[3],
-        properties: Object.assign(Object.assign({}, interval[4]), { [reservedRangeLabelsKey]: [label] }),
+        properties: { ...interval[4], [reservedRangeLabelsKey]: [label] },
         stickiness: interval[5],
     };
 }
@@ -47,7 +36,9 @@ function compressInterval(interval) {
         end,
         sequenceNumber,
         intervalType,
-        Object.assign(Object.assign({}, properties), { [reservedRangeLabelsKey]: undefined }),
+        // remove the `referenceRangeLabels` property as it is already stored
+        // in the `label` field of the summary
+        { ...properties, [reservedRangeLabelsKey]: undefined },
     ];
     if (interval.stickiness !== undefined && interval.stickiness !== IntervalStickiness.END) {
         base.push(interval.stickiness);
@@ -92,8 +83,7 @@ export class LocalIntervalCollection {
      * @returns The interval's existing or newly created id
      */
     ensureSerializedId(serializedInterval) {
-        var _a;
-        let id = (_a = serializedInterval.properties) === null || _a === void 0 ? void 0 : _a[reservedIntervalIdKey];
+        let id = serializedInterval.properties?.[reservedIntervalIdKey];
         if (id === undefined) {
             // Back-compat: 0.39 and earlier did not have IDs on intervals. If an interval from such a client
             // comes over the wire, create a non-unique one based on start/end.
@@ -132,7 +122,6 @@ export class LocalIntervalCollection {
     }
     addInterval(start, end, intervalType, props, op, stickiness = IntervalStickiness.END) {
         var _a;
-        var _b;
         const interval = this.createInterval(start, end, intervalType, op, stickiness);
         if (interval) {
             if (!interval.properties) {
@@ -148,7 +137,7 @@ export class LocalIntervalCollection {
                 }
                 interval.addProperties(props);
             }
-            (_a = (_b = interval.properties)[reservedIntervalIdKey]) !== null && _a !== void 0 ? _a : (_b[reservedIntervalIdKey] = uuid());
+            (_a = interval.properties)[reservedIntervalIdKey] ?? (_a[reservedIntervalIdKey] = uuid());
             this.add(interval);
         }
         return interval;
@@ -208,12 +197,11 @@ export class LocalIntervalCollection {
                     this.removeIntervalFromIndexes(interval);
                 }
             }, () => {
-                var _a;
                 assert(previousInterval !== undefined, 0x3fa /* Invalid interleaving of before/after slide */);
                 pendingChanges--;
                 if (pendingChanges === 0) {
                     this.addIntervalToIndexes(interval);
-                    (_a = this.onPositionChange) === null || _a === void 0 ? void 0 : _a.call(this, interval, previousInterval);
+                    this.onPositionChange?.(interval, previousInterval);
                     previousInterval = undefined;
                 }
             });
@@ -280,7 +268,7 @@ export function makeOpsMap() {
     const rebase = (collection, op, localOpMetadata) => {
         const { localSeq } = localOpMetadata;
         const rebasedValue = collection.rebaseLocalInterval(op.opName, op.value, localSeq);
-        const rebasedOp = Object.assign(Object.assign({}, op), { value: rebasedValue });
+        const rebasedOp = { ...op, value: rebasedValue };
         return { rebasedOp, rebasedLocalOpMetadata: localOpMetadata };
     };
     return new Map([
@@ -374,25 +362,23 @@ export class IntervalCollection extends TypedEventEmitter {
      * {@inheritdoc IIntervalCollection.attachIndex}
      */
     attachIndex(index) {
-        var _a;
         if (!this.attached) {
             throw new LoggingError("The local interval collection must exist");
         }
         for (const interval of this) {
             index.add(interval);
         }
-        (_a = this.localCollection) === null || _a === void 0 ? void 0 : _a.appendIndex(index);
+        this.localCollection?.appendIndex(index);
     }
     /**
      * {@inheritdoc IIntervalCollection.detachIndex}
      */
     detachIndex(index) {
-        var _a;
         if (!this.attached) {
             throw new LoggingError("The local interval collection must exist");
         }
         // Avoid removing intervals if the index does not exist
-        if (!((_a = this.localCollection) === null || _a === void 0 ? void 0 : _a.removeIndex(index))) {
+        if (!this.localCollection?.removeIndex(index)) {
             return false;
         }
         for (const interval of this) {
@@ -401,7 +387,6 @@ export class IntervalCollection extends TypedEventEmitter {
         return true;
     }
     rebasePositionWithSegmentSlide(pos, seqNumberFrom, localSeq) {
-        var _a;
         if (!this.client) {
             throw new LoggingError("mergeTree client must exist");
         }
@@ -412,7 +397,7 @@ export class IntervalCollection extends TypedEventEmitter {
         }, localSeq);
         // if segment is undefined, it slid off the string
         assert(segment !== undefined, 0x54e /* No segment found */);
-        const segoff = (_a = getSlideToSegoff({ segment, offset })) !== null && _a !== void 0 ? _a : segment;
+        const segoff = getSlideToSegoff({ segment, offset }) ?? segment;
         // case happens when rebasing op, but concurrently entire string has been deleted
         if (segoff.segment === undefined || segoff.offset === undefined) {
             return DetachedReferencePosition;
@@ -424,7 +409,7 @@ export class IntervalCollection extends TypedEventEmitter {
         assert(this.client !== undefined, 0x550 /* Client should be defined when computing rebased position */);
         const original = this.localSeqToSerializedInterval.get(localSeq);
         assert(original !== undefined, 0x551 /* Failed to store pending serialized interval info for this localSeq. */);
-        const rebased = Object.assign({}, original);
+        const rebased = { ...original };
         const { start, end, sequenceNumber } = original;
         if (start !== undefined) {
             rebased.start = this.rebasePositionWithSegmentSlide(start, sequenceNumber, localSeq);
@@ -506,7 +491,6 @@ export class IntervalCollection extends TypedEventEmitter {
      * {@inheritdoc IIntervalCollection.add}
      */
     add(start, end, intervalType, props, stickiness = IntervalStickiness.END) {
-        var _a, _b;
         if (!this.localCollection) {
             throw new LoggingError("attach must be called prior to adding intervals");
         }
@@ -522,7 +506,7 @@ export class IntervalCollection extends TypedEventEmitter {
                 end,
                 intervalType,
                 properties: interval.properties,
-                sequenceNumber: (_b = (_a = this.client) === null || _a === void 0 ? void 0 : _a.getCurrentSeq()) !== null && _b !== void 0 ? _b : 0,
+                sequenceNumber: this.client?.getCurrentSeq() ?? 0,
                 start,
                 stickiness,
             };
@@ -654,9 +638,8 @@ export class IntervalCollection extends TypedEventEmitter {
         entries.push(serializedInterval);
     }
     removePendingChange(serializedInterval) {
-        var _a;
         // Change ops always have an ID.
-        const id = (_a = serializedInterval.properties) === null || _a === void 0 ? void 0 : _a[reservedIntervalIdKey];
+        const id = serializedInterval.properties?.[reservedIntervalIdKey];
         if (serializedInterval.start !== undefined) {
             this.removePendingChangeHelper(id, this.pendingChangesStart, serializedInterval);
         }
@@ -671,8 +654,8 @@ export class IntervalCollection extends TypedEventEmitter {
             if (entries.length === 0) {
                 pendingChanges.delete(id);
             }
-            if ((pendingChange === null || pendingChange === void 0 ? void 0 : pendingChange.start) !== serializedInterval.start ||
-                (pendingChange === null || pendingChange === void 0 ? void 0 : pendingChange.end) !== serializedInterval.end) {
+            if (pendingChange?.start !== serializedInterval.start ||
+                pendingChange?.end !== serializedInterval.end) {
                 throw new LoggingError("Mismatch in pending changes");
             }
         }
@@ -687,20 +670,19 @@ export class IntervalCollection extends TypedEventEmitter {
     }
     /** @internal */
     ackChange(serializedInterval, local, op, localOpMetadata) {
-        var _a, _b, _c, _d;
         if (!this.localCollection) {
             throw new LoggingError("Attach must be called before accessing intervals");
         }
         if (local) {
             assert(localOpMetadata !== undefined, 0x552 /* op metadata should be defined for local op */);
-            this.localSeqToSerializedInterval.delete(localOpMetadata === null || localOpMetadata === void 0 ? void 0 : localOpMetadata.localSeq);
+            this.localSeqToSerializedInterval.delete(localOpMetadata?.localSeq);
             // This is an ack from the server. Remove the pending change.
             this.removePendingChange(serializedInterval);
         }
         // Note that the ID is in the property bag only to allow us to find the interval.
         // This API cannot change the ID, and writing to the ID property will result in an exception. So we
         // strip it out of the properties here.
-        const _e = (_a = serializedInterval.properties) !== null && _a !== void 0 ? _a : {}, _f = reservedIntervalIdKey, id = _e[_f], newProps = __rest(_e, [typeof _f === "symbol" ? _f : _f + ""]);
+        const { [reservedIntervalIdKey]: id, ...newProps } = serializedInterval.properties ?? {};
         assert(id !== undefined, 0x3fe /* id must exist on the interval */);
         const interval = this.getIntervalById(id);
         if (!interval) {
@@ -709,9 +691,9 @@ export class IntervalCollection extends TypedEventEmitter {
         }
         if (local) {
             // Let the propertyManager prune its pending change-properties set.
-            (_b = interval.propertyManager) === null || _b === void 0 ? void 0 : _b.ackPendingProperties({
+            interval.propertyManager?.ackPendingProperties({
                 type: MergeTreeDeltaType.ANNOTATE,
-                props: (_c = serializedInterval.properties) !== null && _c !== void 0 ? _c : {},
+                props: serializedInterval.properties ?? {},
             });
             this.ackInterval(interval, op);
         }
@@ -732,7 +714,7 @@ export class IntervalCollection extends TypedEventEmitter {
                 // If changeInterval gives us a new interval, work with that one. Otherwise keep working with
                 // the one we originally found in the tree.
                 newInterval =
-                    (_d = this.localCollection.changeInterval(interval, start, end, op)) !== null && _d !== void 0 ? _d : interval;
+                    this.localCollection.changeInterval(interval, start, end, op) ?? interval;
             }
             const deltaProps = newInterval.addProperties(newProps, true, op.sequenceNumber);
             if (this.onDeserialize) {
@@ -747,18 +729,6 @@ export class IntervalCollection extends TypedEventEmitter {
             }
         }
     }
-    /**
-     * @deprecated - This functionality was useful when adding two intervals at the same start/end positions resulted
-     * in a conflict. This is no longer the case (as of PR#6407), as interval collections support multiple intervals
-     * at the same location and gives each interval a unique id.
-     *
-     * As such, the conflict resolver is never invoked and unnecessary. This API will be removed in an upcoming release.
-     */
-    addConflictResolver(_) {
-        if (!this.localCollection) {
-            throw new LoggingError("attachSequence must be called");
-        }
-    }
     /**
      * {@inheritdoc IIntervalCollection.attachDeserializer}
      */
@@ -782,7 +752,6 @@ export class IntervalCollection extends TypedEventEmitter {
      * @internal
      */
     rebaseLocalInterval(opName, serializedInterval, localSeq) {
-        var _a, _b, _c, _d, _e, _f;
         if (!this.client) {
             // If there's no associated mergeTree client, the originally submitted op is still correct.
             return serializedInterval;
@@ -791,14 +760,14 @@ export class IntervalCollection extends TypedEventEmitter {
             throw new LoggingError("attachSequence must be called");
         }
         const { intervalType, properties } = serializedInterval;
-        const { start: startRebased, end: endRebased } = (_a = this.localSeqToRebasedInterval.get(localSeq)) !== null && _a !== void 0 ? _a : this.computeRebasedPositions(localSeq);
-        const intervalId = properties === null || properties === void 0 ? void 0 : properties[reservedIntervalIdKey];
-        const localInterval = (_b = this.localCollection) === null || _b === void 0 ? void 0 : _b.idIntervalIndex.getIntervalById(intervalId);
+        const { start: startRebased, end: endRebased } = this.localSeqToRebasedInterval.get(localSeq) ?? this.computeRebasedPositions(localSeq);
+        const intervalId = properties?.[reservedIntervalIdKey];
+        const localInterval = this.localCollection?.idIntervalIndex.getIntervalById(intervalId);
         const rebased = {
             start: startRebased,
             end: endRebased,
             intervalType,
-            sequenceNumber: (_d = (_c = this.client) === null || _c === void 0 ? void 0 : _c.getCurrentSeq()) !== null && _d !== void 0 ? _d : 0,
+            sequenceNumber: this.client?.getCurrentSeq() ?? 0,
             properties,
         };
         if (opName === "change" &&
@@ -810,7 +779,7 @@ export class IntervalCollection extends TypedEventEmitter {
         if (startRebased === DetachedReferencePosition ||
             endRebased === DetachedReferencePosition) {
             if (localInterval) {
-                (_e = this.localCollection) === null || _e === void 0 ? void 0 : _e.removeExistingInterval(localInterval);
+                this.localCollection?.removeExistingInterval(localInterval);
             }
             return undefined;
         }
@@ -819,17 +788,16 @@ export class IntervalCollection extends TypedEventEmitter {
             assert(localInterval instanceof SequenceInterval, 0x3a0 /* localInterval must be `SequenceInterval` when used with client */);
             // The rebased op may place this interval's endpoints on different segments. Calling `changeInterval` here
             // updates the local client's state to be consistent with the emitted op.
-            (_f = this.localCollection) === null || _f === void 0 ? void 0 : _f.changeInterval(localInterval, startRebased, endRebased, undefined, localSeq);
+            this.localCollection?.changeInterval(localInterval, startRebased, endRebased, undefined, localSeq);
         }
         return rebased;
     }
     getSlideToSegment(lref) {
-        var _a, _b;
         if (!this.client) {
             throw new LoggingError("client does not exist");
         }
         const segoff = { segment: lref.getSegment(), offset: lref.getOffset() };
-        if (((_b = (_a = segoff.segment) === null || _a === void 0 ? void 0 : _a.localRefs) === null || _b === void 0 ? void 0 : _b.has(lref)) !== true) {
+        if (segoff.segment?.localRefs?.has(lref) !== true) {
             return undefined;
         }
         const newSegoff = getSlideToSegoff(segoff);
@@ -845,7 +813,6 @@ export class IntervalCollection extends TypedEventEmitter {
         lref.refType = refType;
     }
     ackInterval(interval, op) {
-        var _a, _b;
         // Only SequenceIntervals need potential sliding
         if (!(interval instanceof SequenceInterval)) {
             return;
@@ -890,7 +857,7 @@ export class IntervalCollection extends TypedEventEmitter {
                 // remove and rebuild start interval as transient for event
                 this.client.removeLocalReferencePosition(oldInterval.start);
                 oldInterval.start.refType = ReferenceType.Transient;
-                (_a = oldSeg === null || oldSeg === void 0 ? void 0 : oldSeg.localRefs) === null || _a === void 0 ? void 0 : _a.addLocalRef(oldInterval.start, oldInterval.start.getOffset());
+                oldSeg?.localRefs?.addLocalRef(oldInterval.start, oldInterval.start.getOffset());
             }
             if (needsEndUpdate) {
                 const props = interval.end.properties;
@@ -902,7 +869,7 @@ export class IntervalCollection extends TypedEventEmitter {
                 const oldSeg = oldInterval.end.getSegment();
                 this.client.removeLocalReferencePosition(oldInterval.end);
                 oldInterval.end.refType = ReferenceType.Transient;
-                (_b = oldSeg === null || oldSeg === void 0 ? void 0 : oldSeg.localRefs) === null || _b === void 0 ? void 0 : _b.addLocalRef(oldInterval.end, oldInterval.end.getOffset());
+                oldSeg?.localRefs?.addLocalRef(oldInterval.end, oldInterval.end.getOffset());
             }
             this.localCollection.add(interval);
             this.emitChange(interval, oldInterval, true, true, op);
@@ -910,11 +877,10 @@ export class IntervalCollection extends TypedEventEmitter {
     }
     /** @internal */
     ackAdd(serializedInterval, local, op, localOpMetadata) {
-        var _a;
         if (local) {
             assert(localOpMetadata !== undefined, 0x553 /* op metadata should be defined for local op */);
             this.localSeqToSerializedInterval.delete(localOpMetadata.localSeq);
-            const id = (_a = serializedInterval.properties) === null || _a === void 0 ? void 0 : _a[reservedIntervalIdKey];
+            const id = serializedInterval.properties?.[reservedIntervalIdKey];
             const localInterval = this.getIntervalById(id);
             if (localInterval) {
                 this.ackInterval(localInterval, op);
@@ -1068,9 +1034,8 @@ export class IntervalCollection extends TypedEventEmitter {
  * endpoint is a part of.
  */
 export function intervalLocatorFromEndpoint(potentialEndpoint) {
-    var _a;
-    const { interval, [reservedRangeLabelsKey]: collectionNameArray } = (_a = potentialEndpoint.properties) !== null && _a !== void 0 ? _a : {};
-    return interval && (collectionNameArray === null || collectionNameArray === void 0 ? void 0 : collectionNameArray.length) === 1
+    const { interval, [reservedRangeLabelsKey]: collectionNameArray } = potentialEndpoint.properties ?? {};
+    return interval && collectionNameArray?.length === 1
         ? { label: collectionNameArray[0], interval }
         : undefined;
 }