@fluidframework/sequence 2.0.0-internal.7.3.0 → 2.0.0-internal.7.4.1

package/CHANGELOG.md

@@ -1,5 +1,62 @@
 # @fluidframework/sequence
 
+## 2.0.0-internal.7.4.0
+
+### Minor Changes
+
+-   sequence: `change` and `changeProperties` are now a single method ([#18676](https://github.com/microsoft/FluidFramework/issues/18676)) [12c83d2696](https://github.com/microsoft/FluidFramework/commits/12c83d26962a1d76db6eb0ccad31fd6a7976a1af)
+
+    Instead of having two separate methods to change the endpoints of an interval and the properties, they have been combined into a
+    single method that will change the endpoints, properties, or both, depending on the arguments passed in. The signature
+    of this combined method is now updated as well.
+
+    The new way to use the change method is to call it with an interval id as the first parameter and an object containing
+    the desired portions of the interval to update as the second parameter. For the object parameter, the `endpoints` field
+    should be an object containing the new `start` and `end` values for the interval, and the `properties` field should be
+    an object containing the new properties for the interval. Either the `endpoints` field or the `properties` field can be
+    omitted, and if neither are present, `change` will return `undefined`.
+
+    The new usage of the change method is as follows:
+
+    Change interval endpoints: `change(id, { endpoints: { start: 1, end: 4 } });`
+
+    Change interval properties: `change(id { props: { a: 1 } });`
+
+    Change interval endpoints and properties: `change(id, { endpoints: { start: 1, end: 4 }, props: { a: 1 } });`
+
+-   sequence: Deprecated findOverlappingIntervals API ([#18036](https://github.com/microsoft/FluidFramework/issues/18036)) [52b864ea42](https://github.com/microsoft/FluidFramework/commits/52b864ea42759403771f2cbcb282b0ba19ce42f6)
+
+    The `findOverlappingIntervals` API from `IntervalCollection` has been deprecated. This functionality is moved to the
+    `OverlappingIntervalsIndex`. Users should independently attach the index to the collection and utilize the API
+    accordingly, for instance:
+
+    ```typescript
+    const overlappingIntervalsIndex = createOverlappingIntervalsIndex(sharedString);
+    collection.attachIndex(overlappingIntervalsIndex);
+    const result = overlappingIntervalsIndex.findOverlappingIntervals(start, end);
+    ```
+
+-   sequence: Deprecated previousInterval and nextInterval APIs ([#18060](https://github.com/microsoft/FluidFramework/issues/18060)) [05fb45d26f](https://github.com/microsoft/FluidFramework/commits/05fb45d26f3065297e219a4bce5763e25bdcffc9)
+
+    The `previousInterval` and `nextInterval` APIs from `IntervalCollection` have been deprecated. These functions are moved
+    to the `EndpointIndex`. Users should independently attach the index to the collection and utilize the API accordingly,
+    for instance:
+
+    ```typescript
+    const endpointIndex = createEndpointIndex(sharedString);
+    collection.attachIndex(endpointIndex);
+
+    const result1 = endpointIndex.previousInterval(pos);
+    const result2 = endpointIndex.nextInterval(pos);
+    ```
+
+-   sequence: Deprecated ICombiningOp, PropertiesRollback.Rewrite, and SharedString.annotateMarkerNotifyConsensus ([#18318](https://github.com/microsoft/FluidFramework/issues/18318)) [e67c2cac5f](https://github.com/microsoft/FluidFramework/commits/e67c2cac5f275fc5c875c0bc044bbb72aaf76648)
+
+    The `ICombiningOp` and its usage in various APIs has been deprecated. APIs affected include
+    `SharedSegmentSequence.annotateRange` and `SharedString.annotateMarker`. `SharedString.annotateMarkerNotifyConsensus`
+    has also been deprecated, because it is related to combining ops. This functionality had no test coverage and was
+    largely unused.
+
 ## 2.0.0-internal.7.3.0
 
 Dependency updates only.

package/api-extractor-lint.json

@@ -0,0 +1,13 @@
+{
+	"$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
+	"extends": "../../../common/build/build-common/api-extractor-lint.json",
+	"messages": {
+		"extractorMessageReporting": {
+			// TODO: remove once base config has this enabled as an error
+			"ae-incompatible-release-tags": {
+				"logLevel": "error",
+				"addToApiReportFile": false
+			}
+		}
+	}
+}

package/api-extractor.json

@@ -1,7 +1,12 @@
 {
 	"$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
-	"extends": "@fluidframework/build-common/api-extractor-base.json",
-	"dtsRollup": {
-		"enabled": true
+	"extends": "../../../common/build/build-common/api-extractor-base.json",
+	"messages": {
+		"extractorMessageReporting": {
+			// TODO: Add missing documentation and remove this rule override
+			"ae-undocumented": {
+				"logLevel": "none"
+			}
+		}
 	}
 }

package/api-report/sequence.api.md

@@ -50,52 +50,52 @@ import { SummarySerializer } from '@fluidframework/shared-object-base';
 import { TextSegment } from '@fluidframework/merge-tree';
 import { TypedEventEmitter } from '@fluid-internal/client-utils';
 
-// @alpha
+// @internal
 export function appendAddIntervalToRevertibles(interval: SequenceInterval, revertibles: SharedStringRevertible[]): SharedStringRevertible[];
 
-// @alpha
+// @internal
 export function appendChangeIntervalToRevertibles(string: SharedString, newInterval: SequenceInterval, previousInterval: SequenceInterval, revertibles: SharedStringRevertible[]): SharedStringRevertible[];
 
-// @alpha
+// @internal
 export function appendDeleteIntervalToRevertibles(string: SharedString, interval: SequenceInterval, revertibles: SharedStringRevertible[]): SharedStringRevertible[];
 
-// @alpha
+// @internal
 export function appendIntervalPropertyChangedToRevertibles(interval: SequenceInterval, deltas: PropertySet, revertibles: SharedStringRevertible[]): SharedStringRevertible[];
 
-// @alpha
+// @internal
 export function appendSharedStringDeltaToRevertibles(string: SharedString, delta: SequenceDeltaEvent, revertibles: SharedStringRevertible[]): void;
 
-// @public (undocumented)
+// @internal (undocumented)
 export function createEndpointIndex(sharedString: SharedString): IEndpointIndex<SequenceInterval>;
 
-// @public (undocumented)
+// @internal (undocumented)
 export function createEndpointInRangeIndex(sharedString: SharedString): IEndpointInRangeIndex<SequenceInterval>;
 
-// @public (undocumented)
+// @internal (undocumented)
 export function createIdIntervalIndex<TInterval extends ISerializableInterval>(): IIdIntervalIndex<TInterval>;
 
-// @public (undocumented)
+// @internal (undocumented)
 export function createOverlappingIntervalsIndex(sharedString: SharedString): IOverlappingIntervalsIndex<SequenceInterval>;
 
-// @public (undocumented)
+// @internal (undocumented)
 export function createOverlappingSequenceIntervalsIndex(sharedString: SharedString): SequenceIntervalIndexes.Overlapping;
 
-// @public (undocumented)
+// @internal (undocumented)
 export function createStartpointInRangeIndex(sharedString: SharedString): IStartpointInRangeIndex<SequenceInterval>;
 
-// @public (undocumented)
+// @alpha (undocumented)
 export type DeserializeCallback = (properties: PropertySet) => void;
 
-// @alpha
+// @internal
 export function discardSharedStringRevertibles(sharedString: SharedString, revertibles: SharedStringRevertible[]): void;
 
-// @public
+// @internal
 export function getTextAndMarkers(sharedString: SharedString, label: string, start?: number, end?: number): {
     parallelText: string[];
     parallelMarkers: Marker[];
 };
 
-// @public (undocumented)
+// @internal (undocumented)
 export interface IEndpointIndex<TInterval extends ISerializableInterval> extends IntervalIndex<TInterval> {
     // (undocumented)
     nextInterval(pos: number): TInterval | undefined;
@@ -103,13 +103,13 @@ export interface IEndpointIndex<TInterval extends ISerializableInterval> extends
     previousInterval(pos: number): TInterval | undefined;
 }
 
-// @public
+// @internal
 export interface IEndpointInRangeIndex<TInterval extends ISerializableInterval> extends IntervalIndex<TInterval> {
     // (undocumented)
     findIntervalsWithEndpointInRange(start: number, end: number): TInterval[];
 }
 
-// @public (undocumented)
+// @internal (undocumented)
 export interface IIdIntervalIndex<TInterval extends ISerializableInterval> extends IntervalIndex<TInterval>, Iterable<TInterval> {
     // (undocumented)
     [Symbol.iterator](): Iterator<TInterval>;
@@ -117,22 +117,20 @@ export interface IIdIntervalIndex<TInterval extends ISerializableInterval> exten
     getIntervalById(id: string): TInterval | undefined;
 }
 
-// @public
+// @alpha
 export interface IInterval {
     // (undocumented)
     clone(): IInterval;
     compare(b: IInterval): number;
     compareEnd(b: IInterval): number;
     compareStart(b: IInterval): number;
-    // @internal
     modify(label: string, start: SequencePlace | undefined, end: SequencePlace | undefined, op?: ISequencedDocumentMessage, localSeq?: number, useNewSlidingBehavior?: boolean): IInterval | undefined;
     // (undocumented)
     overlaps(b: IInterval): boolean;
-    // @internal
     union(b: IInterval): IInterval;
 }
 
-// @public
+// @alpha
 export interface IIntervalCollection<TInterval extends ISerializableInterval> extends TypedEventEmitter<IIntervalCollectionEvent<TInterval>> {
     // (undocumented)
     [Symbol.iterator](): Iterator<TInterval>;
@@ -148,7 +146,14 @@ export interface IIntervalCollection<TInterval extends ISerializableInterval> ex
     // (undocumented)
     readonly attached: boolean;
     attachIndex(index: IntervalIndex<TInterval>): void;
+    // @deprecated
     change(id: string, start: SequencePlace, end: SequencePlace): TInterval | undefined;
+    change(id: string, { start, end, props }: {
+        start?: SequencePlace;
+        end?: SequencePlace;
+        props?: PropertySet;
+    }): TInterval | undefined;
+    // @deprecated
     changeProperties(id: string, props: PropertySet): any;
     // (undocumented)
     CreateBackwardIteratorWithEndPosition(endPosition: number): Iterator<TInterval>;
@@ -159,33 +164,33 @@ export interface IIntervalCollection<TInterval extends ISerializableInterval> ex
     // (undocumented)
     CreateForwardIteratorWithStartPosition(startPosition: number): Iterator<TInterval>;
     detachIndex(index: IntervalIndex<TInterval>): boolean;
-    // (undocumented)
+    // @deprecated (undocumented)
     findOverlappingIntervals(startPosition: number, endPosition: number): TInterval[];
     gatherIterationResults(results: TInterval[], iteratesForward: boolean, start?: number, end?: number): void;
     // (undocumented)
     getIntervalById(id: string): TInterval | undefined;
     map(fn: (interval: TInterval) => void): void;
-    // (undocumented)
+    // @deprecated (undocumented)
     nextInterval(pos: number): TInterval | undefined;
-    // (undocumented)
+    // @deprecated (undocumented)
     previousInterval(pos: number): TInterval | undefined;
     removeIntervalById(id: string): TInterval | undefined;
 }
 
-// @public
+// @alpha
 export interface IIntervalCollectionEvent<TInterval extends ISerializableInterval> extends IEvent {
     (event: "changeInterval", listener: (interval: TInterval, previousInterval: TInterval, local: boolean, op: ISequencedDocumentMessage | undefined, slide: boolean) => void): any;
     (event: "addInterval" | "deleteInterval", listener: (interval: TInterval, local: boolean, op: ISequencedDocumentMessage | undefined) => void): any;
     (event: "propertyChanged", listener: (interval: TInterval, propertyDeltas: PropertySet, local: boolean, op: ISequencedDocumentMessage | undefined) => void): any;
 }
 
-// @public @sealed @deprecated (undocumented)
+// @internal @sealed @deprecated (undocumented)
 export interface IIntervalHelpers<TInterval extends ISerializableInterval> {
     // (undocumented)
     create(label: string, start: SequencePlace | undefined, end: SequencePlace | undefined, client: Client | undefined, intervalType: IntervalType, op?: ISequencedDocumentMessage, fromSnapshot?: boolean, useNewSlidingBehavior?: boolean): TInterval;
 }
 
-// @public @deprecated (undocumented)
+// @internal @deprecated (undocumented)
 export interface IJSONRunSegment<T> extends IJSONSegment {
     // (undocumented)
     items: Serializable<T>[];
@@ -197,7 +202,7 @@ export interface IMapMessageLocalMetadata {
     localSeq: number;
 }
 
-// @public
+// @alpha
 export interface InteriorSequencePlace {
     // (undocumented)
     pos: number;
@@ -205,13 +210,13 @@ export interface InteriorSequencePlace {
     side: Side;
 }
 
-// @public
+// @internal
 export class Interval implements ISerializableInterval {
     constructor(start: number, end: number, props?: PropertySet);
-    // @internal (undocumented)
+    // (undocumented)
     addProperties(newProps: PropertySet, collaborating?: boolean, seq?: number, op?: ICombiningOp): PropertySet | undefined;
     addPropertySet(props: PropertySet): void;
-    // @internal (undocumented)
+    // (undocumented)
     auxProps: PropertySet[] | undefined;
     // (undocumented)
     clone(): Interval;
@@ -225,37 +230,35 @@ export class Interval implements ISerializableInterval {
     getIntervalId(): string;
     // (undocumented)
     getProperties(): PropertySet;
-    // @internal
     modify(label: string, start?: SequencePlace, end?: SequencePlace, op?: ISequencedDocumentMessage): Interval | undefined;
     // (undocumented)
     overlaps(b: Interval): boolean;
     properties: PropertySet;
-    // @internal (undocumented)
+    // (undocumented)
     propertyManager: PropertiesManager;
-    // @internal (undocumented)
+    // (undocumented)
     serialize(): ISerializedInterval;
     // (undocumented)
     start: number;
-    // @internal
     union(b: Interval): Interval;
 }
 
-// @public
+// @alpha
 export interface IntervalIndex<TInterval extends ISerializableInterval> {
     add(interval: TInterval): void;
     remove(interval: TInterval): void;
 }
 
-// @public
+// @internal
 export interface IntervalLocator {
     interval: SequenceInterval;
     label: string;
 }
 
-// @public
+// @internal
 export function intervalLocatorFromEndpoint(potentialEndpoint: LocalReferencePosition): IntervalLocator | undefined;
 
-// @alpha
+// @internal
 export const IntervalOpType: {
     readonly ADD: "add";
     readonly DELETE: "delete";
@@ -264,7 +267,10 @@ export const IntervalOpType: {
     readonly POSITION_REMOVE: "positionRemove";
 };
 
-// @alpha
+// @internal (undocumented)
+export type IntervalOpType = (typeof IntervalOpType)[keyof typeof IntervalOpType];
+
+// @internal
 export type IntervalRevertible = {
     event: typeof IntervalOpType.CHANGE;
     interval: SequenceInterval;
@@ -298,7 +304,7 @@ export type IntervalRevertible = {
     mergeTreeRevertible: MergeTreeDeltaRevertible;
 };
 
-// @internal
+// @alpha
 export const IntervalStickiness: {
     readonly NONE: 0;
     readonly START: 1;
@@ -306,10 +312,10 @@ export const IntervalStickiness: {
     readonly FULL: 3;
 };
 
-// @internal
+// @alpha
 export type IntervalStickiness = (typeof IntervalStickiness)[keyof typeof IntervalStickiness];
 
-// @public (undocumented)
+// @alpha (undocumented)
 export enum IntervalType {
     // @deprecated (undocumented)
     Nest = 1,
@@ -320,14 +326,14 @@ export enum IntervalType {
     Transient = 4
 }
 
-// @public (undocumented)
+// @internal (undocumented)
 export interface IOverlappingIntervalsIndex<TInterval extends ISerializableInterval> extends IntervalIndex<TInterval> {
     // (undocumented)
     findOverlappingIntervals(start: SequencePlace, end: SequencePlace): TInterval[];
     gatherIterationResults(results: TInterval[], iteratesForward: boolean, start?: SequencePlace, end?: SequencePlace): void;
 }
 
-// @public
+// @alpha
 export interface ISequenceDeltaRange<TOperation extends MergeTreeDeltaOperationTypes = MergeTreeDeltaOperationTypes> {
     operation: TOperation;
     position: number;
@@ -335,19 +341,19 @@ export interface ISequenceDeltaRange<TOperation extends MergeTreeDeltaOperationT
     segment: ISegment;
 }
 
-// @public (undocumented)
+// @alpha (undocumented)
 export interface ISerializableInterval extends IInterval {
-    // @internal (undocumented)
+    // (undocumented)
     addProperties(props: PropertySet, collaborating?: boolean, seq?: number): PropertySet | undefined;
     getIntervalId(): string | undefined;
     properties: PropertySet;
-    // @internal (undocumented)
+    // (undocumented)
     propertyManager: PropertiesManager;
-    // @internal (undocumented)
+    // (undocumented)
     serialize(): ISerializedInterval;
 }
 
-// @internal
+// @alpha
 export interface ISerializedInterval {
     end: number | "start" | "end";
     // (undocumented)
@@ -361,13 +367,13 @@ export interface ISerializedInterval {
     stickiness?: IntervalStickiness;
 }
 
-// @public (undocumented)
+// @alpha (undocumented)
 export interface ISharedIntervalCollection<TInterval extends ISerializableInterval> {
     // (undocumented)
     getIntervalCollection(label: string): IIntervalCollection<TInterval>;
 }
 
-// @public
+// @alpha
 export interface ISharedSegmentSequenceEvents extends ISharedObjectEvents {
     // (undocumented)
     (event: "createIntervalCollection", listener: (label: string, local: boolean, target: IEventThisPlaceHolder) => void): any;
@@ -377,28 +383,29 @@ export interface ISharedSegmentSequenceEvents extends ISharedObjectEvents {
     (event: "maintenance", listener: (event: SequenceMaintenanceEvent, target: IEventThisPlaceHolder) => void): any;
 }
 
-// @public
+// @alpha
 export interface ISharedString extends SharedSegmentSequence<SharedStringSegment> {
     insertMarker(pos: number, refType: ReferenceType, props?: PropertySet): IMergeTreeInsertMsg | undefined;
     insertText(pos: number, text: string, props?: PropertySet): void;
     posFromRelativePos(relativePos: IRelativePosition): number;
 }
 
-// @public
+// @internal
 export interface IStartpointInRangeIndex<TInterval extends ISerializableInterval> extends IntervalIndex<TInterval> {
     // (undocumented)
     findIntervalsWithStartpointInRange(start: number, end: number): TInterval[];
 }
 
-// @internal
+// @internal @deprecated
 export interface IValueOpEmitter {
-    emit(opName: string, previousValue: any, params: any, localOpMetadata: IMapMessageLocalMetadata): void;
+    // @deprecated
+    emit(opName: IntervalOpType, previousValue: undefined, params: SerializedIntervalDelta, localOpMetadata: IMapMessageLocalMetadata): void;
 }
 
-// @alpha
+// @internal
 export function revertSharedStringRevertibles(sharedString: SharedString, revertibles: SharedStringRevertible[]): void;
 
-// @public
+// @alpha
 export class SequenceDeltaEvent extends SequenceEvent<MergeTreeDeltaOperationType> {
     constructor(opArgs: IMergeTreeDeltaOpArgs, deltaArgs: IMergeTreeDeltaCallbackArgs, mergeTreeClient: Client);
     readonly isLocal: boolean;
@@ -406,7 +413,7 @@ export class SequenceDeltaEvent extends SequenceEvent<MergeTreeDeltaOperationTyp
     readonly opArgs: IMergeTreeDeltaOpArgs;
 }
 
-// @public
+// @alpha
 export abstract class SequenceEvent<TOperation extends MergeTreeDeltaOperationTypes = MergeTreeDeltaOperationTypes> {
     constructor(deltaArgs: IMergeTreeDeltaCallbackArgs<TOperation>, mergeTreeClient: Client);
     get clientId(): string | undefined;
@@ -419,14 +426,13 @@ export abstract class SequenceEvent<TOperation extends MergeTreeDeltaOperationTy
     get ranges(): readonly Readonly<ISequenceDeltaRange<TOperation>>[];
 }
 
-// @public
+// @alpha
 export class SequenceInterval implements ISerializableInterval {
     constructor(client: Client,
     start: LocalReferencePosition,
     end: LocalReferencePosition, intervalType: IntervalType, props?: PropertySet, startSide?: Side, endSide?: Side);
-    // @internal
     addPositionChangeListeners(beforePositionChange: () => void, afterPositionChange: () => void): void;
-    // @internal (undocumented)
+    // (undocumented)
     addProperties(newProps: PropertySet, collab?: boolean, seq?: number, op?: ICombiningOp): PropertySet | undefined;
     // (undocumented)
     clone(): SequenceInterval;
@@ -439,32 +445,29 @@ export class SequenceInterval implements ISerializableInterval {
     getIntervalId(): string;
     // (undocumented)
     intervalType: IntervalType;
-    // @internal
     modify(label: string, start: SequencePlace | undefined, end: SequencePlace | undefined, op?: ISequencedDocumentMessage, localSeq?: number, useNewSlidingBehavior?: boolean): SequenceInterval;
     // (undocumented)
     overlaps(b: SequenceInterval): boolean;
     // (undocumented)
     overlapsPos(bstart: number, bend: number): boolean;
     properties: PropertySet;
-    // @internal (undocumented)
+    // (undocumented)
     propertyManager: PropertiesManager;
-    // @internal
     removePositionChangeListeners(): void;
-    // @internal (undocumented)
+    // (undocumented)
     serialize(): ISerializedInterval;
     start: LocalReferencePosition;
     // (undocumented)
     readonly startSide: Side;
-    // @internal (undocumented)
+    // (undocumented)
     get stickiness(): IntervalStickiness;
-    // @internal
     union(b: SequenceInterval): SequenceInterval;
 }
 
-// @public @deprecated (undocumented)
+// @internal @deprecated (undocumented)
 export const sequenceIntervalHelpers: IIntervalHelpers<SequenceInterval>;
 
-// @public
+// @internal
 export namespace SequenceIntervalIndexes {
     export interface Overlapping extends IOverlappingIntervalsIndex<SequenceInterval> {
         findOverlappingIntervalsBySegoff(startSegoff: {
@@ -477,14 +480,14 @@ export namespace SequenceIntervalIndexes {
     }
 }
 
-// @public
+// @alpha
 export class SequenceMaintenanceEvent extends SequenceEvent<MergeTreeMaintenanceType> {
     constructor(opArgs: IMergeTreeDeltaOpArgs | undefined, deltaArgs: IMergeTreeMaintenanceCallbackArgs, mergeTreeClient: Client);
     // (undocumented)
     readonly opArgs: IMergeTreeDeltaOpArgs | undefined;
 }
 
-// @public
+// @internal
 export interface SequenceOptions {
     // (undocumented)
     [key: string]: boolean;
@@ -492,13 +495,13 @@ export interface SequenceOptions {
     mergeTreeReferencesCanSlideToEndpoint: boolean;
 }
 
-// @public
+// @alpha
 export type SequencePlace = number | "start" | "end" | InteriorSequencePlace;
 
 // @internal
 export type SerializedIntervalDelta = Omit<ISerializedInterval, "start" | "end" | "properties"> & Partial<Pick<ISerializedInterval, "start" | "end" | "properties">>;
 
-// @public @deprecated (undocumented)
+// @internal @deprecated (undocumented)
 export class SharedIntervalCollection extends SharedObject implements ISharedIntervalCollection<Interval> {
     // (undocumented)
     readonly [Symbol.toStringTag]: string;
@@ -522,7 +525,7 @@ export class SharedIntervalCollection extends SharedObject implements ISharedInt
     protected summarizeCore(serializer: IFluidSerializer): ISummaryTreeWithStats;
 }
 
-// @public @deprecated
+// @internal @deprecated
 export class SharedIntervalCollectionFactory implements IChannelFactory {
     // (undocumented)
     static readonly Attributes: IChannelAttributes;
@@ -538,7 +541,7 @@ export class SharedIntervalCollectionFactory implements IChannelFactory {
     get type(): string;
 }
 
-// @public (undocumented)
+// @alpha (undocumented)
 export abstract class SharedSegmentSequence<T extends ISegment> extends SharedObject<ISharedSegmentSequenceEvents> implements ISharedIntervalCollection<SequenceInterval>, MergeTreeRevertibleDriver {
     constructor(dataStoreRuntime: IFluidDataStoreRuntime, id: string, attributes: IChannelAttributes, segmentFromSpec: (spec: IJSONSegment) => ISegment);
     annotateRange(start: number, end: number, props: PropertySet, combiningOp?: ICombiningOp): void;
@@ -571,7 +574,6 @@ export abstract class SharedSegmentSequence<T extends ISegment> extends SharedOb
     getStackContext(startPos: number, rangeLabels: string[]): RangeStackMap;
     // @deprecated (undocumented)
     groupOperation(groupOp: IMergeTreeGroupMsg): void;
-    // @internal
     protected guardReentrancy: <TRet>(callback: () => TRet) => TRet;
     // (undocumented)
     id: string;
@@ -609,7 +611,7 @@ export abstract class SharedSegmentSequence<T extends ISegment> extends SharedOb
     walkSegments<TClientData>(handler: ISegmentAction<TClientData>, start?: number, end?: number, accum?: TClientData, splitRange?: boolean): void;
 }
 
-// @public @deprecated (undocumented)
+// @internal @deprecated (undocumented)
 export class SharedSequence<T> extends SharedSegmentSequence<SubSequence<T>> {
     constructor(document: IFluidDataStoreRuntime, id: string, attributes: IChannelAttributes, specToSegment: (spec: IJSONSegment) => ISegment);
     getItemCount(): number;
@@ -622,10 +624,11 @@ export class SharedSequence<T> extends SharedSegmentSequence<SubSequence<T>> {
     remove(start: number, end: number): void;
 }
 
-// @public
+// @alpha
 export class SharedString extends SharedSegmentSequence<SharedStringSegment> implements ISharedString {
     constructor(document: IFluidDataStoreRuntime, id: string, attributes: IChannelAttributes);
     annotateMarker(marker: Marker, props: PropertySet, combiningOp?: ICombiningOp): void;
+    // @deprecated
     annotateMarkerNotifyConsensus(marker: Marker, props: PropertySet, callback: (m: Marker) => void): void;
     static create(runtime: IFluidDataStoreRuntime, id?: string): SharedString;
     // @deprecated
@@ -653,7 +656,7 @@ export class SharedString extends SharedSegmentSequence<SharedStringSegment> imp
     searchForMarker(startPos: number, markerLabel: string, forwards?: boolean): Marker | undefined;
 }
 
-// @public (undocumented)
+// @alpha (undocumented)
 export class SharedStringFactory implements IChannelFactory {
     // (undocumented)
     static readonly Attributes: IChannelAttributes;
@@ -671,13 +674,13 @@ export class SharedStringFactory implements IChannelFactory {
     get type(): string;
 }
 
-// @alpha
+// @internal
 export type SharedStringRevertible = MergeTreeDeltaRevertible | IntervalRevertible;
 
-// @public (undocumented)
+// @alpha (undocumented)
 export type SharedStringSegment = TextSegment | Marker;
 
-// @public
+// @alpha
 export enum Side {
     // (undocumented)
     After = 1,
@@ -685,7 +688,7 @@ export enum Side {
     Before = 0
 }
 
-// @public @deprecated (undocumented)
+// @internal @deprecated (undocumented)
 export class SubSequence<T> extends BaseSegment {
     constructor(items: Serializable<T>[]);
     // (undocumented)

package/dist/{defaultMap.js → defaultMap.cjs}

@@ -8,7 +8,7 @@ exports.DefaultMap = void 0;
 const shared_object_base_1 = require("@fluidframework/shared-object-base");
 const client_utils_1 = require("@fluid-internal/client-utils");
 const core_utils_1 = require("@fluidframework/core-utils");
-const localValues_1 = require("./localValues");
+const localValues_1 = require("./localValues.cjs");
 /**
  * A DefaultMap is a map-like distributed data structure, supporting operations on values stored by
  * string key locations.
@@ -272,8 +272,11 @@ class DefaultMap {
                 const localValue = this.data.get(op.key);
                 (0, core_utils_1.assert)(localValue !== undefined, 0x3f8 /* Local value expected on resubmission */);
                 const handler = localValue.getOpHandler(op.value.opName);
-                const { rebasedOp, rebasedLocalOpMetadata } = handler.rebase(localValue.value, op.value, localOpMetadata);
-                this.submitMessage({ ...op, value: rebasedOp }, rebasedLocalOpMetadata);
+                const rebased = handler.rebase(localValue.value, op.value, localOpMetadata);
+                if (rebased !== undefined) {
+                    const { rebasedOp, rebasedLocalOpMetadata } = rebased;
+                    this.submitMessage({ ...op, value: rebasedOp }, rebasedLocalOpMetadata);
+                }
             },
             getStashedOpLocalMetadata: (op) => {
                 (0, core_utils_1.assert)(false, 0x016 /* "apply stashed op not implemented for custom value type ops" */);
@@ -287,7 +290,9 @@ class DefaultMap {
      * @param key - The key of the map that the value type will be stored on
      * @returns A value op emitter for the given key
      */
+    // eslint-disable-next-line import/no-deprecated
     makeMapValueOpEmitter(key) {
+        // eslint-disable-next-line import/no-deprecated
         const emit = (opName, previousValue, params, localOpMetadata) => {
             const translatedParams = (0, shared_object_base_1.makeHandlesSerializable)(params, this.serializer, this.handle);
             const op = {
@@ -306,4 +311,4 @@ class DefaultMap {
     }
 }
 exports.DefaultMap = DefaultMap;
-//# sourceMappingURL=defaultMap.js.map
+//# sourceMappingURL=defaultMap.cjs.map