@fluidframework/sequence 2.0.0-internal.7.2.2 → 2.0.0-internal.7.4.0

package/lib/intervalCollection.js

@@ -1,46 +1,50 @@
+"use strict";
 /*!
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.intervalLocatorFromEndpoint = exports.IntervalCollection = exports.makeOpsMap = exports.IntervalCollectionValueType = exports.SequenceIntervalCollectionValueType = exports.LocalIntervalCollection = exports.createIntervalIndex = exports.computeStickinessFromSide = exports.endpointPosAndSide = exports.sidesFromStickiness = exports.Side = void 0;
 /* eslint-disable no-bitwise */
 /* eslint-disable import/no-deprecated */
-import { TypedEventEmitter } from "@fluid-internal/client-utils";
-import { assert } from "@fluidframework/core-utils";
-import { addProperties, createMap, getSlideToSegoff, MergeTreeDeltaType, ReferenceType, refTypeIncludesFlag, reservedRangeLabelsKey, UnassignedSequenceNumber, DetachedReferencePosition, UniversalSequenceNumber, SlidingPreference, } from "@fluidframework/merge-tree";
-import { LoggingError, UsageError } from "@fluidframework/telemetry-utils";
-import { v4 as uuid } from "uuid";
-import { IntervalOpType, IntervalStickiness, IntervalType, SequenceInterval, createPositionReferenceFromSegoff, endReferenceSlidingPreference, startReferenceSlidingPreference, sequenceIntervalHelpers, createInterval, } from "./intervals";
-import { EndpointIndex, OverlappingIntervalsIndex, createIdIntervalIndex, } from "./intervalIndex";
+const client_utils_1 = require("@fluid-internal/client-utils");
+const core_utils_1 = require("@fluidframework/core-utils");
+const merge_tree_1 = require("@fluidframework/merge-tree");
+const telemetry_utils_1 = require("@fluidframework/telemetry-utils");
+const uuid_1 = require("uuid");
+const intervals_1 = require("./intervals");
+const intervalIndex_1 = require("./intervalIndex");
 /**
  * Defines a side relative to a character in a sequence.
  *
  * @remarks See {@link SequencePlace} for additional context on usage.
- * @public
+ * @alpha
  */
-export var Side;
+var Side;
 (function (Side) {
     Side[Side["Before"] = 0] = "Before";
     Side[Side["After"] = 1] = "After";
-})(Side || (Side = {}));
+})(Side || (exports.Side = Side = {}));
 const reservedIntervalIdKey = "intervalId";
-export function sidesFromStickiness(stickiness) {
-    const startSide = (stickiness & IntervalStickiness.START) !== 0 ? Side.After : Side.Before;
-    const endSide = (stickiness & IntervalStickiness.END) !== 0 ? Side.Before : Side.After;
+function sidesFromStickiness(stickiness) {
+    const startSide = (stickiness & intervals_1.IntervalStickiness.START) !== 0 ? Side.After : Side.Before;
+    const endSide = (stickiness & intervals_1.IntervalStickiness.END) !== 0 ? Side.Before : Side.After;
     return { startSide, endSide };
 }
+exports.sidesFromStickiness = sidesFromStickiness;
 /**
  * Decompress an interval after loading a summary from JSON. The exact format
  * of this compression is unspecified and subject to change
  */
 function decompressInterval(interval, label) {
-    const stickiness = interval[5] ?? IntervalStickiness.END;
+    const stickiness = interval[5] ?? intervals_1.IntervalStickiness.END;
     const { startSide, endSide } = sidesFromStickiness(stickiness);
     return {
         start: interval[0],
         end: interval[1],
         sequenceNumber: interval[2],
         intervalType: interval[3],
-        properties: { ...interval[4], [reservedRangeLabelsKey]: [label] },
+        properties: { ...interval[4], [merge_tree_1.reservedRangeLabelsKey]: [label] },
         stickiness,
         startSide,
         endSide,
@@ -59,15 +63,15 @@ function compressInterval(interval) {
         intervalType,
         // remove the `referenceRangeLabels` property as it is already stored
         // in the `label` field of the summary
-        { ...properties, [reservedRangeLabelsKey]: undefined },
+        { ...properties, [merge_tree_1.reservedRangeLabelsKey]: undefined },
     ];
-    if (interval.stickiness !== undefined && interval.stickiness !== IntervalStickiness.END) {
+    if (interval.stickiness !== undefined && interval.stickiness !== intervals_1.IntervalStickiness.END) {
         // reassignment to make it easier for typescript to reason about types
         base = [...base, interval.stickiness];
     }
     return base;
 }
-export function endpointPosAndSide(start, end) {
+function endpointPosAndSide(start, end) {
     const startIsPlainEndpoint = typeof start === "number" || start === "start" || start === "end";
     const endIsPlainEndpoint = typeof end === "number" || end === "start" || end === "end";
     const startSide = startIsPlainEndpoint ? Side.Before : start?.side;
@@ -81,30 +85,33 @@ export function endpointPosAndSide(start, end) {
         endPos,
     };
 }
+exports.endpointPosAndSide = endpointPosAndSide;
 function toSequencePlace(pos, side) {
     return typeof pos === "number" ? { pos, side } : pos;
 }
 function toOptionalSequencePlace(pos, side = Side.Before) {
     return typeof pos === "number" ? { pos, side } : pos;
 }
-export function computeStickinessFromSide(startPos = -1, startSide = Side.Before, endPos = -1, endSide = Side.Before) {
-    let stickiness = IntervalStickiness.NONE;
+function computeStickinessFromSide(startPos = -1, startSide = Side.Before, endPos = -1, endSide = Side.Before) {
+    let stickiness = intervals_1.IntervalStickiness.NONE;
     if (startSide === Side.After || startPos === "start") {
-        stickiness |= IntervalStickiness.START;
+        stickiness |= intervals_1.IntervalStickiness.START;
     }
     if (endSide === Side.Before || endPos === "end") {
-        stickiness |= IntervalStickiness.END;
+        stickiness |= intervals_1.IntervalStickiness.END;
     }
     return stickiness;
 }
-export function createIntervalIndex() {
+exports.computeStickinessFromSide = computeStickinessFromSide;
+function createIntervalIndex() {
     const helpers = {
-        create: createInterval,
+        create: intervals_1.createInterval,
     };
     const lc = new LocalIntervalCollection(undefined, "", helpers, {});
     return lc;
 }
-export class LocalIntervalCollection {
+exports.createIntervalIndex = createIntervalIndex;
+class LocalIntervalCollection {
     constructor(client, label, helpers, options, 
     /** Callback invoked each time one of the endpoints of an interval slides. */
     onPositionChange) {
@@ -113,9 +120,9 @@ export class LocalIntervalCollection {
         this.helpers = helpers;
         this.options = options;
         this.onPositionChange = onPositionChange;
-        this.overlappingIntervalsIndex = new OverlappingIntervalsIndex(client, helpers);
-        this.idIntervalIndex = createIdIntervalIndex();
-        this.endIntervalIndex = new EndpointIndex(client, helpers);
+        this.overlappingIntervalsIndex = new intervalIndex_1.OverlappingIntervalsIndex(client, helpers);
+        this.idIntervalIndex = (0, intervalIndex_1.createIdIntervalIndex)();
+        this.endIntervalIndex = new intervalIndex_1.EndpointIndex(client, helpers);
         this.indexes = new Set([
             this.overlappingIntervalsIndex,
             this.idIntervalIndex,
@@ -144,7 +151,7 @@ export class LocalIntervalCollection {
             const newProps = {
                 [reservedIntervalIdKey]: id,
             };
-            serializedInterval.properties = addProperties(serializedInterval.properties, newProps);
+            serializedInterval.properties = (0, merge_tree_1.addProperties)(serializedInterval.properties, newProps);
         }
         // Make the ID immutable for safety's sake.
         Object.defineProperty(serializedInterval.properties, reservedIntervalIdKey, {
@@ -177,25 +184,25 @@ export class LocalIntervalCollection {
         const interval = this.createInterval(start, end, intervalType, op);
         if (interval) {
             if (!interval.properties) {
-                interval.properties = createMap();
+                interval.properties = (0, merge_tree_1.createMap)();
             }
             if (props) {
                 // This check is intended to prevent scenarios where a random interval is created and then
                 // inserted into a collection. The aim is to ensure that the collection is created first
                 // then the user can create/add intervals based on the collection
-                if (props[reservedRangeLabelsKey] !== undefined &&
-                    props[reservedRangeLabelsKey][0] !== this.label) {
-                    throw new LoggingError("Adding an interval that belongs to another interval collection is not permitted");
+                if (props[merge_tree_1.reservedRangeLabelsKey] !== undefined &&
+                    props[merge_tree_1.reservedRangeLabelsKey][0] !== this.label) {
+                    throw new telemetry_utils_1.LoggingError("Adding an interval that belongs to another interval collection is not permitted");
                 }
                 interval.addProperties(props);
             }
-            (_a = interval.properties)[reservedIntervalIdKey] ?? (_a[reservedIntervalIdKey] = uuid());
+            (_a = interval.properties)[reservedIntervalIdKey] ?? (_a[reservedIntervalIdKey] = (0, uuid_1.v4)());
             this.add(interval);
         }
         return interval;
     }
     linkEndpointsToInterval(interval) {
-        if (interval instanceof SequenceInterval) {
+        if (interval instanceof intervals_1.SequenceInterval) {
             interval.start.addProperties({ interval });
             interval.end.addProperties({ interval });
         }
@@ -234,9 +241,9 @@ export class LocalIntervalCollection {
                 // either, so this must be special-cased.
                 return ref;
             }
-            return this.client.createLocalReferencePosition(segment, ref.getOffset(), ReferenceType.Transient, ref.properties, ref.slidingPreference, ref.canSlideToEndpoint);
+            return this.client.createLocalReferencePosition(segment, ref.getOffset(), merge_tree_1.ReferenceType.Transient, ref.properties, ref.slidingPreference, ref.canSlideToEndpoint);
         };
-        if (interval instanceof SequenceInterval) {
+        if (interval instanceof intervals_1.SequenceInterval) {
             let previousInterval;
             let pendingChanges = 0;
             interval.addPositionChangeListeners(() => {
@@ -249,7 +256,7 @@ export class LocalIntervalCollection {
                     this.removeIntervalFromIndexes(interval);
                 }
             }, () => {
-                assert(previousInterval !== undefined, 0x3fa /* Invalid interleaving of before/after slide */);
+                (0, core_utils_1.assert)(previousInterval !== undefined, 0x3fa /* Invalid interleaving of before/after slide */);
                 pendingChanges--;
                 if (pendingChanges === 0) {
                     this.addIntervalToIndexes(interval);
@@ -260,21 +267,22 @@ export class LocalIntervalCollection {
         }
     }
     removeIntervalListeners(interval) {
-        if (interval instanceof SequenceInterval) {
+        if (interval instanceof intervals_1.SequenceInterval) {
             interval.removePositionChangeListeners();
         }
     }
 }
+exports.LocalIntervalCollection = LocalIntervalCollection;
 LocalIntervalCollection.legacyIdPrefix = "legacy";
 class SequenceIntervalCollectionFactory {
     load(emitter, raw = [], options) {
-        return new IntervalCollection(sequenceIntervalHelpers, true, emitter, raw, options);
+        return new IntervalCollection(intervals_1.sequenceIntervalHelpers, true, emitter, raw, options);
     }
     store(value) {
         return value.serializeInternal();
     }
 }
-export class SequenceIntervalCollectionValueType {
+class SequenceIntervalCollectionValueType {
     get name() {
         return SequenceIntervalCollectionValueType.Name;
     }
@@ -285,13 +293,14 @@ export class SequenceIntervalCollectionValueType {
         return SequenceIntervalCollectionValueType._ops;
     }
 }
+exports.SequenceIntervalCollectionValueType = SequenceIntervalCollectionValueType;
 SequenceIntervalCollectionValueType.Name = "sharedStringIntervalCollection";
 SequenceIntervalCollectionValueType._factory = new SequenceIntervalCollectionFactory();
 SequenceIntervalCollectionValueType._ops = makeOpsMap();
 class IntervalCollectionFactory {
     load(emitter, raw = [], options) {
         const helpers = {
-            create: createInterval,
+            create: intervals_1.createInterval,
         };
         const collection = new IntervalCollection(helpers, false, emitter, raw, options);
         collection.attachGraph(undefined, "");
@@ -301,7 +310,7 @@ class IntervalCollectionFactory {
         return value.serializeInternal();
     }
 }
-export class IntervalCollectionValueType {
+class IntervalCollectionValueType {
     get name() {
         return IntervalCollectionValueType.Name;
     }
@@ -312,19 +321,23 @@ export class IntervalCollectionValueType {
         return IntervalCollectionValueType._ops;
     }
 }
+exports.IntervalCollectionValueType = IntervalCollectionValueType;
 IntervalCollectionValueType.Name = "sharedIntervalCollection";
 IntervalCollectionValueType._factory = new IntervalCollectionFactory();
 IntervalCollectionValueType._ops = makeOpsMap();
-export function makeOpsMap() {
+function makeOpsMap() {
     const rebase = (collection, op, localOpMetadata) => {
         const { localSeq } = localOpMetadata;
         const rebasedValue = collection.rebaseLocalInterval(op.opName, op.value, localSeq);
+        if (rebasedValue === undefined) {
+            return undefined;
+        }
         const rebasedOp = { ...op, value: rebasedValue };
         return { rebasedOp, rebasedLocalOpMetadata: localOpMetadata };
     };
     return new Map([
         [
-            IntervalOpType.ADD,
+            intervals_1.IntervalOpType.ADD,
             {
                 process: (collection, params, local, op, localOpMetadata) => {
                     // if params is undefined, the interval was deleted during
@@ -332,17 +345,17 @@ export function makeOpsMap() {
                     if (!params) {
                         return;
                     }
-                    assert(op !== undefined, 0x3fb /* op should exist here */);
+                    (0, core_utils_1.assert)(op !== undefined, 0x3fb /* op should exist here */);
                     collection.ackAdd(params, local, op, localOpMetadata);
                 },
                 rebase,
             },
         ],
         [
-            IntervalOpType.DELETE,
+            intervals_1.IntervalOpType.DELETE,
             {
                 process: (collection, params, local, op) => {
-                    assert(op !== undefined, 0x3fc /* op should exist here */);
+                    (0, core_utils_1.assert)(op !== undefined, 0x3fc /* op should exist here */);
                     collection.ackDelete(params, local, op);
                 },
                 rebase: (collection, op, localOpMetadata) => {
@@ -352,7 +365,7 @@ export function makeOpsMap() {
             },
         ],
         [
-            IntervalOpType.CHANGE,
+            intervals_1.IntervalOpType.CHANGE,
             {
                 process: (collection, params, local, op, localOpMetadata) => {
                     // if params is undefined, the interval was deleted during
@@ -360,7 +373,7 @@ export function makeOpsMap() {
                     if (!params) {
                         return;
                     }
-                    assert(op !== undefined, 0x3fd /* op should exist here */);
+                    (0, core_utils_1.assert)(op !== undefined, 0x3fd /* op should exist here */);
                     collection.ackChange(params, local, op, localOpMetadata);
                 },
                 rebase,
@@ -368,6 +381,7 @@ export function makeOpsMap() {
         ],
     ]);
 }
+exports.makeOpsMap = makeOpsMap;
 class IntervalCollectionIterator {
     constructor(collection, iteratesForward = true, start, end) {
         this.results = [];
@@ -395,7 +409,7 @@ const isSequencePlace = (place) => {
 /**
  * {@inheritdoc IIntervalCollection}
  */
-export class IntervalCollection extends TypedEventEmitter {
+class IntervalCollection extends client_utils_1.TypedEventEmitter {
     get attached() {
         return !!this.localCollection;
     }
@@ -419,7 +433,7 @@ export class IntervalCollection extends TypedEventEmitter {
      */
     attachIndex(index) {
         if (!this.attached) {
-            throw new LoggingError("The local interval collection must exist");
+            throw new telemetry_utils_1.LoggingError("The local interval collection must exist");
         }
         for (const interval of this) {
             index.add(interval);
@@ -431,7 +445,7 @@ export class IntervalCollection extends TypedEventEmitter {
      */
     detachIndex(index) {
         if (!this.attached) {
-            throw new LoggingError("The local interval collection must exist");
+            throw new telemetry_utils_1.LoggingError("The local interval collection must exist");
         }
         // Avoid removing intervals if the index does not exist
         if (!this.localCollection?.removeIndex(index)) {
@@ -444,7 +458,7 @@ export class IntervalCollection extends TypedEventEmitter {
     }
     rebasePositionWithSegmentSlide(pos, seqNumberFrom, localSeq) {
         if (!this.client) {
-            throw new LoggingError("mergeTree client must exist");
+            throw new telemetry_utils_1.LoggingError("mergeTree client must exist");
         }
         if (pos === "start" || pos === "end") {
             return pos;
@@ -455,19 +469,19 @@ export class IntervalCollection extends TypedEventEmitter {
             clientId: this.client.getLongClientId(clientId),
         }, localSeq);
         // if segment is undefined, it slid off the string
-        assert(segment !== undefined, 0x54e /* No segment found */);
-        const segoff = getSlideToSegoff({ segment, offset }, undefined, this.options.mergeTreeReferencesCanSlideToEndpoint) ?? segment;
+        (0, core_utils_1.assert)(segment !== undefined, 0x54e /* No segment found */);
+        const segoff = (0, merge_tree_1.getSlideToSegoff)({ segment, offset }, undefined, this.options.mergeTreeReferencesCanSlideToEndpoint) ?? segment;
         // case happens when rebasing op, but concurrently entire string has been deleted
         if (segoff.segment === undefined || segoff.offset === undefined) {
-            return DetachedReferencePosition;
+            return merge_tree_1.DetachedReferencePosition;
         }
-        assert(offset !== undefined && 0 <= offset && offset < segment.cachedLength, 0x54f /* Invalid offset */);
+        (0, core_utils_1.assert)(offset !== undefined && 0 <= offset && offset < segment.cachedLength, 0x54f /* Invalid offset */);
         return this.client.findReconnectionPosition(segoff.segment, localSeq) + segoff.offset;
     }
     computeRebasedPositions(localSeq) {
-        assert(this.client !== undefined, 0x550 /* Client should be defined when computing rebased position */);
+        (0, core_utils_1.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. */);
+        (0, core_utils_1.assert)(original !== undefined, 0x551 /* Failed to store pending serialized interval info for this localSeq. */);
         const rebased = { ...original };
         const { start, end, sequenceNumber } = original;
         if (start !== undefined) {
@@ -481,10 +495,10 @@ export class IntervalCollection extends TypedEventEmitter {
     /** @internal */
     attachGraph(client, label) {
         if (this.attached) {
-            throw new LoggingError("Only supports one Sequence attach");
+            throw new telemetry_utils_1.LoggingError("Only supports one Sequence attach");
         }
         if (client === undefined && this.requiresClient) {
-            throw new LoggingError("Client required for this collection");
+            throw new telemetry_utils_1.LoggingError("Client required for this collection");
         }
         // Instantiate the local interval collection based on the saved intervals
         this.client = client;
@@ -530,11 +544,11 @@ export class IntervalCollection extends TypedEventEmitter {
         // is restored as single-endpoint changes re-use previous references.
         let startRefType;
         let endRefType;
-        if (previousInterval instanceof SequenceInterval) {
+        if (previousInterval instanceof intervals_1.SequenceInterval) {
             startRefType = previousInterval.start.refType;
             endRefType = previousInterval.end.refType;
-            previousInterval.start.refType = ReferenceType.Transient;
-            previousInterval.end.refType = ReferenceType.Transient;
+            previousInterval.start.refType = merge_tree_1.ReferenceType.Transient;
+            previousInterval.end.refType = merge_tree_1.ReferenceType.Transient;
             this.emit("changeInterval", interval, previousInterval, local, op, slide);
             previousInterval.start.refType = startRefType;
             previousInterval.end.refType = endRefType;
@@ -548,14 +562,14 @@ export class IntervalCollection extends TypedEventEmitter {
      */
     getIntervalById(id) {
         if (!this.localCollection) {
-            throw new LoggingError("attach must be called before accessing intervals");
+            throw new telemetry_utils_1.LoggingError("attach must be called before accessing intervals");
         }
         return this.localCollection.idIntervalIndex.getIntervalById(id);
     }
     assertStickinessEnabled(start, end) {
         if (!(typeof start === "number" && typeof end === "number") &&
             !this.options.intervalStickinessEnabled) {
-            throw new UsageError("attempted to set interval stickiness without enabling `intervalStickinessEnabled` feature flag");
+            throw new telemetry_utils_1.UsageError("attempted to set interval stickiness without enabling `intervalStickinessEnabled` feature flag");
         }
     }
     add(start, end, intervalType, props) {
@@ -565,26 +579,26 @@ export class IntervalCollection extends TypedEventEmitter {
         let properties;
         if (isSequencePlace(start)) {
             intStart = start;
-            assert(end !== undefined, 0x7c0 /* end must be defined */);
+            (0, core_utils_1.assert)(end !== undefined, 0x7c0 /* end must be defined */);
             intEnd = end;
-            assert(intervalType !== undefined, 0x7c1 /* intervalType must be defined */);
+            (0, core_utils_1.assert)(intervalType !== undefined, 0x7c1 /* intervalType must be defined */);
             type = intervalType;
             properties = props;
         }
         else {
             intStart = start.start;
             intEnd = start.end;
-            type = IntervalType.SlideOnRemove;
+            type = intervals_1.IntervalType.SlideOnRemove;
             properties = start.props;
         }
         if (!this.localCollection) {
-            throw new LoggingError("attach must be called prior to adding intervals");
+            throw new telemetry_utils_1.LoggingError("attach must be called prior to adding intervals");
         }
-        if (type & IntervalType.Transient) {
-            throw new LoggingError("Can not add transient intervals");
+        if (type & intervals_1.IntervalType.Transient) {
+            throw new telemetry_utils_1.LoggingError("Can not add transient intervals");
         }
         const { startSide, endSide, startPos, endPos } = endpointPosAndSide(intStart, intEnd);
-        assert(startPos !== undefined &&
+        (0, core_utils_1.assert)(startPos !== undefined &&
             endPos !== undefined &&
             startSide !== undefined &&
             endSide !== undefined, 0x793 /* start and end cannot be undefined because they were not passed in as undefined */);
@@ -592,7 +606,7 @@ export class IntervalCollection extends TypedEventEmitter {
         this.assertStickinessEnabled(intStart, intEnd);
         const interval = this.localCollection.addInterval(toSequencePlace(startPos, startSide), toSequencePlace(endPos, endSide), type, properties);
         if (interval) {
-            if (!this.isCollaborating && interval instanceof SequenceInterval) {
+            if (!this.isCollaborating && interval instanceof intervals_1.SequenceInterval) {
                 setSlideOnRemove(interval.start);
                 setSlideOnRemove(interval.end);
             }
@@ -616,7 +630,7 @@ export class IntervalCollection extends TypedEventEmitter {
     }
     deleteExistingInterval(interval, local, op) {
         if (!this.localCollection) {
-            throw new LoggingError("Attach must be called before accessing intervals");
+            throw new telemetry_utils_1.LoggingError("Attach must be called before accessing intervals");
         }
         // The given interval is known to exist in the collection.
         this.localCollection.removeExistingInterval(interval);
@@ -640,7 +654,7 @@ export class IntervalCollection extends TypedEventEmitter {
      */
     removeIntervalById(id) {
         if (!this.localCollection) {
-            throw new LoggingError("Attach must be called before accessing intervals");
+            throw new telemetry_utils_1.LoggingError("Attach must be called before accessing intervals");
         }
         const interval = this.localCollection.idIntervalIndex.getIntervalById(id);
         if (interval) {
@@ -650,58 +664,54 @@ export class IntervalCollection extends TypedEventEmitter {
     }
     /**
      * {@inheritdoc IIntervalCollection.changeProperties}
+     * @deprecated - call change with the id and an object containing the new props values
      */
     changeProperties(id, props) {
-        if (!this.attached) {
-            throw new LoggingError("Attach must be called before accessing intervals");
-        }
-        if (typeof id !== "string") {
-            throw new LoggingError("Change API requires an ID that is a string");
-        }
-        if (!props) {
-            throw new LoggingError("changeProperties should be called with a property set");
-        }
-        // prevent the overwriting of an interval label, it should remain unchanged
-        // once it has been inserted into the collection.
-        if (props[reservedRangeLabelsKey] !== undefined) {
-            throw new LoggingError("The label property should not be modified once inserted to the collection");
+        this.change(id, { props });
+    }
+    change(arg1, arg2, arg3) {
+        const id = arg1;
+        let start;
+        let end;
+        let props;
+        if (isSequencePlace(arg2)) {
+            start = arg2;
+            end = arg3;
         }
-        const interval = this.getIntervalById(id);
-        if (interval) {
-            const deltaProps = interval.addProperties(props, true, this.isCollaborating ? UnassignedSequenceNumber : UniversalSequenceNumber);
-            const serializedInterval = interval.serialize();
-            // Emit a change op that will only change properties. Add the ID to
-            // the property bag provided by the caller.
-            serializedInterval.start = undefined;
-            serializedInterval.end = undefined;
-            serializedInterval.properties = props;
-            serializedInterval.properties[reservedIntervalIdKey] = interval.getIntervalId();
-            const localSeq = this.getNextLocalSeq();
-            this.localSeqToSerializedInterval.set(localSeq, serializedInterval);
-            this.emitter.emit("change", undefined, serializedInterval, { localSeq });
-            this.emit("propertyChanged", interval, deltaProps, true, undefined);
+        else {
+            start = arg2.start;
+            end = arg2.end;
+            props = arg2.props;
         }
-    }
-    /**
-     * {@inheritdoc IIntervalCollection.change}
-     */
-    change(id, start, end) {
         if (!this.localCollection) {
-            throw new LoggingError("Attach must be called before accessing intervals");
+            throw new telemetry_utils_1.LoggingError("Attach must be called before accessing intervals");
         }
         // Force id to be a string.
         if (typeof id !== "string") {
-            throw new LoggingError("Change API requires an ID that is a string");
+            throw new telemetry_utils_1.UsageError("Change API requires an ID that is a string");
+        }
+        // Ensure that both start and end are defined or both are undefined.
+        if ((start === undefined) !== (end === undefined)) {
+            throw new telemetry_utils_1.UsageError("Change API requires both start and end to be defined or undefined");
+        }
+        // prevent the overwriting of an interval label, it should remain unchanged
+        // once it has been inserted into the collection.
+        if (props?.[merge_tree_1.reservedRangeLabelsKey] !== undefined) {
+            throw new telemetry_utils_1.UsageError("The label property should not be modified once inserted to the collection");
         }
         const interval = this.getIntervalById(id);
         if (interval) {
-            const newInterval = this.localCollection.changeInterval(interval, start, end);
-            if (!newInterval) {
-                return undefined;
+            let deltaProps;
+            let newInterval;
+            if (props !== undefined) {
+                deltaProps = interval.addProperties(props, true, this.isCollaborating ? merge_tree_1.UnassignedSequenceNumber : merge_tree_1.UniversalSequenceNumber);
             }
-            if (!this.isCollaborating && newInterval instanceof SequenceInterval) {
-                setSlideOnRemove(newInterval.start);
-                setSlideOnRemove(newInterval.end);
+            if (start !== undefined && end !== undefined) {
+                newInterval = this.localCollection.changeInterval(interval, start, end);
+                if (!this.isCollaborating && newInterval instanceof intervals_1.SequenceInterval) {
+                    setSlideOnRemove(newInterval.start);
+                    setSlideOnRemove(newInterval.end);
+                }
             }
             const serializedInterval = interval.serialize();
             const { startPos, startSide, endPos, endSide } = endpointPosAndSide(start, end);
@@ -711,15 +721,21 @@ export class IntervalCollection extends TypedEventEmitter {
             serializedInterval.startSide = startSide;
             serializedInterval.endSide = endSide;
             serializedInterval.stickiness = stickiness;
-            // Emit a property bag containing only the ID, as we don't intend for this op to change any properties.
+            // Emit a property bag containing the ID and the other (if any) properties changed
             serializedInterval.properties = {
                 [reservedIntervalIdKey]: interval.getIntervalId(),
+                ...props,
             };
             const localSeq = this.getNextLocalSeq();
             this.localSeqToSerializedInterval.set(localSeq, serializedInterval);
             this.emitter.emit("change", undefined, serializedInterval, { localSeq });
-            this.addPendingChange(id, serializedInterval);
-            this.emitChange(newInterval, interval, true, false);
+            if (deltaProps !== undefined) {
+                this.emit("propertyChanged", interval, deltaProps, true, undefined);
+            }
+            if (newInterval) {
+                this.addPendingChange(id, serializedInterval);
+                this.emitChange(newInterval, interval, true, false);
+            }
             return newInterval;
         }
         // No interval to change
@@ -766,7 +782,7 @@ export class IntervalCollection extends TypedEventEmitter {
             }
             if (pendingChange?.start !== serializedInterval.start ||
                 pendingChange?.end !== serializedInterval.end) {
-                throw new LoggingError("Mismatch in pending changes");
+                throw new telemetry_utils_1.LoggingError("Mismatch in pending changes");
             }
         }
     }
@@ -781,10 +797,10 @@ export class IntervalCollection extends TypedEventEmitter {
     /** @internal */
     ackChange(serializedInterval, local, op, localOpMetadata) {
         if (!this.localCollection) {
-            throw new LoggingError("Attach must be called before accessing intervals");
+            throw new telemetry_utils_1.LoggingError("Attach must be called before accessing intervals");
         }
         if (local) {
-            assert(localOpMetadata !== undefined, 0x552 /* op metadata should be defined for local op */);
+            (0, core_utils_1.assert)(localOpMetadata !== undefined, 0x552 /* op metadata should be defined for local op */);
             this.localSeqToSerializedInterval.delete(localOpMetadata?.localSeq);
             // This is an ack from the server. Remove the pending change.
             this.removePendingChange(serializedInterval);
@@ -793,7 +809,7 @@ export class IntervalCollection extends TypedEventEmitter {
         // 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 { [reservedIntervalIdKey]: id, ...newProps } = serializedInterval.properties ?? {};
-        assert(id !== undefined, 0x3fe /* id must exist on the interval */);
+        (0, core_utils_1.assert)(id !== undefined, 0x3fe /* id must exist on the interval */);
         const interval = this.getIntervalById(id);
         if (!interval) {
             // The interval has been removed locally; no-op.
@@ -802,7 +818,7 @@ export class IntervalCollection extends TypedEventEmitter {
         if (local) {
             // Let the propertyManager prune its pending change-properties set.
             interval.propertyManager?.ackPendingProperties({
-                type: MergeTreeDeltaType.ANNOTATE,
+                type: merge_tree_1.MergeTreeDeltaType.ANNOTATE,
                 props: serializedInterval.properties ?? {},
             });
             this.ackInterval(interval, op);
@@ -867,7 +883,7 @@ export class IntervalCollection extends TypedEventEmitter {
             return serializedInterval;
         }
         if (!this.attached) {
-            throw new LoggingError("attachSequence must be called");
+            throw new telemetry_utils_1.LoggingError("attachSequence must be called");
         }
         const { intervalType, properties, stickiness, startSide, endSide } = serializedInterval;
         const { start: startRebased, end: endRebased } = this.localSeqToRebasedInterval.get(localSeq) ?? this.computeRebasedPositions(localSeq);
@@ -890,8 +906,8 @@ export class IntervalCollection extends TypedEventEmitter {
             this.addPendingChange(intervalId, rebased);
         }
         // if the interval slid off the string, rebase the op to be a noop and delete the interval.
-        if (startRebased === DetachedReferencePosition ||
-            endRebased === DetachedReferencePosition) {
+        if (startRebased === merge_tree_1.DetachedReferencePosition ||
+            endRebased === merge_tree_1.DetachedReferencePosition) {
             if (localInterval) {
                 this.localCollection?.removeExistingInterval(localInterval);
             }
@@ -899,7 +915,7 @@ export class IntervalCollection extends TypedEventEmitter {
         }
         if (localInterval !== undefined) {
             // we know we must be using `SequenceInterval` because `this.client` exists
-            assert(localInterval instanceof SequenceInterval, 0x3a0 /* localInterval must be `SequenceInterval` when used with client */);
+            (0, core_utils_1.assert)(localInterval instanceof intervals_1.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.
             this.localCollection?.changeInterval(localInterval, toOptionalSequencePlace(startRebased, startSide), toOptionalSequencePlace(endRebased, endSide), undefined, localSeq);
@@ -908,13 +924,13 @@ export class IntervalCollection extends TypedEventEmitter {
     }
     getSlideToSegment(lref) {
         if (!this.client) {
-            throw new LoggingError("client does not exist");
+            throw new telemetry_utils_1.LoggingError("client does not exist");
         }
         const segoff = { segment: lref.getSegment(), offset: lref.getOffset() };
         if (segoff.segment?.localRefs?.has(lref) !== true) {
             return undefined;
         }
-        const newSegoff = getSlideToSegoff(segoff, undefined, this.options.mergeTreeReferencesCanSlideToEndpoint);
+        const newSegoff = (0, merge_tree_1.getSlideToSegoff)(segoff, undefined, this.options.mergeTreeReferencesCanSlideToEndpoint);
         const value = segoff.segment === newSegoff.segment && segoff.offset === newSegoff.offset
             ? undefined
             : newSegoff;
@@ -922,11 +938,11 @@ export class IntervalCollection extends TypedEventEmitter {
     }
     ackInterval(interval, op) {
         // Only SequenceIntervals need potential sliding
-        if (!(interval instanceof SequenceInterval)) {
+        if (!(interval instanceof intervals_1.SequenceInterval)) {
             return;
         }
-        if (!refTypeIncludesFlag(interval.start, ReferenceType.StayOnRemove) &&
-            !refTypeIncludesFlag(interval.end, ReferenceType.StayOnRemove)) {
+        if (!(0, merge_tree_1.refTypeIncludesFlag)(interval.start, merge_tree_1.ReferenceType.StayOnRemove) &&
+            !(0, merge_tree_1.refTypeIncludesFlag)(interval.end, merge_tree_1.ReferenceType.StayOnRemove)) {
             return;
         }
         const newStart = this.getSlideToSegment(interval.start);
@@ -944,7 +960,7 @@ export class IntervalCollection extends TypedEventEmitter {
         const needsEndUpdate = newEnd !== undefined && !hasPendingEndChange;
         if (needsStartUpdate || needsEndUpdate) {
             if (!this.localCollection) {
-                throw new LoggingError("Attach must be called before accessing intervals");
+                throw new telemetry_utils_1.LoggingError("Attach must be called before accessing intervals");
             }
             // `interval`'s endpoints will get modified in-place, so clone it prior to doing so for event emission.
             const oldInterval = interval.clone();
@@ -953,32 +969,32 @@ export class IntervalCollection extends TypedEventEmitter {
             // This ensures that the correct listeners are added to the LocalReferencePosition.
             this.localCollection.removeExistingInterval(interval);
             if (!this.client) {
-                throw new LoggingError("client does not exist");
+                throw new telemetry_utils_1.LoggingError("client does not exist");
             }
             if (needsStartUpdate) {
                 const props = interval.start.properties;
-                interval.start = createPositionReferenceFromSegoff(this.client, newStart, interval.start.refType, op, undefined, undefined, startReferenceSlidingPreference(interval.stickiness), startReferenceSlidingPreference(interval.stickiness) ===
-                    SlidingPreference.BACKWARD);
+                interval.start = (0, intervals_1.createPositionReferenceFromSegoff)(this.client, newStart, interval.start.refType, op, undefined, undefined, (0, intervals_1.startReferenceSlidingPreference)(interval.stickiness), (0, intervals_1.startReferenceSlidingPreference)(interval.stickiness) ===
+                    merge_tree_1.SlidingPreference.BACKWARD);
                 if (props) {
                     interval.start.addProperties(props);
                 }
                 const oldSeg = oldInterval.start.getSegment();
                 // remove and rebuild start interval as transient for event
                 this.client.removeLocalReferencePosition(oldInterval.start);
-                oldInterval.start.refType = ReferenceType.Transient;
+                oldInterval.start.refType = merge_tree_1.ReferenceType.Transient;
                 oldSeg?.localRefs?.addLocalRef(oldInterval.start, oldInterval.start.getOffset());
             }
             if (needsEndUpdate) {
                 const props = interval.end.properties;
-                interval.end = createPositionReferenceFromSegoff(this.client, newEnd, interval.end.refType, op, undefined, undefined, endReferenceSlidingPreference(interval.stickiness), endReferenceSlidingPreference(interval.stickiness) ===
-                    SlidingPreference.FORWARD);
+                interval.end = (0, intervals_1.createPositionReferenceFromSegoff)(this.client, newEnd, interval.end.refType, op, undefined, undefined, (0, intervals_1.endReferenceSlidingPreference)(interval.stickiness), (0, intervals_1.endReferenceSlidingPreference)(interval.stickiness) ===
+                    merge_tree_1.SlidingPreference.FORWARD);
                 if (props) {
                     interval.end.addProperties(props);
                 }
                 // remove and rebuild end interval as transient for event
                 const oldSeg = oldInterval.end.getSegment();
                 this.client.removeLocalReferencePosition(oldInterval.end);
-                oldInterval.end.refType = ReferenceType.Transient;
+                oldInterval.end.refType = merge_tree_1.ReferenceType.Transient;
                 oldSeg?.localRefs?.addLocalRef(oldInterval.end, oldInterval.end.getOffset());
             }
             this.localCollection.add(interval);
@@ -988,7 +1004,7 @@ export class IntervalCollection extends TypedEventEmitter {
     /** @internal */
     ackAdd(serializedInterval, local, op, localOpMetadata) {
         if (local) {
-            assert(localOpMetadata !== undefined, 0x553 /* op metadata should be defined for local op */);
+            (0, core_utils_1.assert)(localOpMetadata !== undefined, 0x553 /* op metadata should be defined for local op */);
             this.localSeqToSerializedInterval.delete(localOpMetadata.localSeq);
             const id = serializedInterval.properties?.[reservedIntervalIdKey];
             const localInterval = this.getIntervalById(id);
@@ -998,7 +1014,7 @@ export class IntervalCollection extends TypedEventEmitter {
             return;
         }
         if (!this.localCollection) {
-            throw new LoggingError("attachSequence must be called");
+            throw new telemetry_utils_1.LoggingError("attachSequence must be called");
         }
         this.localCollection.ensureSerializedId(serializedInterval);
         const interval = this.localCollection.addInterval(toSequencePlace(serializedInterval.start, serializedInterval.startSide ?? Side.Before), toSequencePlace(serializedInterval.end, serializedInterval.endSide ?? Side.Before), serializedInterval.intervalType, serializedInterval.properties, op);
@@ -1014,12 +1030,12 @@ export class IntervalCollection extends TypedEventEmitter {
     ackDelete(serializedInterval, local, op) {
         if (local) {
             // Local ops were applied when the message was created and there's no "pending delete"
-            // state to bookkeep: remote operation application takes into account possibility of
+            // state to book keep: remote operation application takes into account possibility of
             // locally deleted interval whenever a lookup happens.
             return;
         }
         if (!this.localCollection) {
-            throw new LoggingError("attach must be called prior to deleting intervals");
+            throw new telemetry_utils_1.LoggingError("attach must be called prior to deleting intervals");
         }
         const id = this.localCollection.ensureSerializedId(serializedInterval);
         const interval = this.localCollection.idIntervalIndex.getIntervalById(id);
@@ -1032,7 +1048,7 @@ export class IntervalCollection extends TypedEventEmitter {
      */
     serializeInternal() {
         if (!this.localCollection) {
-            throw new LoggingError("attachSequence must be called");
+            throw new telemetry_utils_1.LoggingError("attachSequence must be called");
         }
         return this.localCollection.serialize();
     }
@@ -1085,7 +1101,7 @@ export class IntervalCollection extends TypedEventEmitter {
      */
     findOverlappingIntervals(startPosition, endPosition) {
         if (!this.localCollection) {
-            throw new LoggingError("attachSequence must be called");
+            throw new telemetry_utils_1.LoggingError("attachSequence must be called");
         }
         return this.localCollection.overlappingIntervalsIndex.findOverlappingIntervals(startPosition, endPosition);
     }
@@ -1094,7 +1110,7 @@ export class IntervalCollection extends TypedEventEmitter {
      */
     map(fn) {
         if (!this.localCollection) {
-            throw new LoggingError("attachSequence must be called");
+            throw new telemetry_utils_1.LoggingError("attachSequence must be called");
         }
         for (const interval of this.localCollection.idIntervalIndex) {
             fn(interval);
@@ -1105,7 +1121,7 @@ export class IntervalCollection extends TypedEventEmitter {
      */
     previousInterval(pos) {
         if (!this.localCollection) {
-            throw new LoggingError("attachSequence must be called");
+            throw new telemetry_utils_1.LoggingError("attachSequence must be called");
         }
         return this.localCollection.endIntervalIndex.previousInterval(pos);
     }
@@ -1114,15 +1130,16 @@ export class IntervalCollection extends TypedEventEmitter {
      */
     nextInterval(pos) {
         if (!this.localCollection) {
-            throw new LoggingError("attachSequence must be called");
+            throw new telemetry_utils_1.LoggingError("attachSequence must be called");
         }
         return this.localCollection.endIntervalIndex.nextInterval(pos);
     }
 }
+exports.IntervalCollection = IntervalCollection;
 function setSlideOnRemove(lref) {
     let refType = lref.refType;
-    refType = refType & ~ReferenceType.StayOnRemove;
-    refType = refType | ReferenceType.SlideOnRemove;
+    refType = refType & ~merge_tree_1.ReferenceType.StayOnRemove;
+    refType = refType | merge_tree_1.ReferenceType.SlideOnRemove;
     lref.refType = refType;
 }
 /**
@@ -1130,12 +1147,13 @@ function setSlideOnRemove(lref) {
  * @returns undefined if the reference position is not the endpoint of any interval (e.g. it was created
  * on the merge tree directly by app code), otherwise an {@link IntervalLocator} for the interval this
  * endpoint is a part of.
- * @public
+ * @internal
  */
-export function intervalLocatorFromEndpoint(potentialEndpoint) {
-    const { interval, [reservedRangeLabelsKey]: collectionNameArray } = potentialEndpoint.properties ?? {};
+function intervalLocatorFromEndpoint(potentialEndpoint) {
+    const { interval, [merge_tree_1.reservedRangeLabelsKey]: collectionNameArray } = potentialEndpoint.properties ?? {};
     return interval && collectionNameArray?.length === 1
         ? { label: collectionNameArray[0], interval }
         : undefined;
 }
+exports.intervalLocatorFromEndpoint = intervalLocatorFromEndpoint;
 //# sourceMappingURL=intervalCollection.js.map