@fluidframework/sequence 2.0.0-internal.6.4.0 → 2.0.0-internal.7.0.0

package/src/intervalIndex/overlappingIntervalsIndex.ts

@@ -14,6 +14,7 @@ import {
 } from "../intervals";
 import { IntervalNode, IntervalTree } from "../intervalTree";
 import { SharedString } from "../sharedString";
+import { SequencePlace, endpointPosAndSide } from "../intervalCollection";
 import { IntervalIndex } from "./intervalIndex";
 
 export interface IOverlappingIntervalsIndex<TInterval extends ISerializableInterval>
@@ -22,7 +23,7 @@ export interface IOverlappingIntervalsIndex<TInterval extends ISerializableInter
 	 * @returns an array of all intervals contained in this collection that overlap the range
 	 * `[start end]`.
 	 */
-	findOverlappingIntervals(start: number, end: number): TInterval[];
+	findOverlappingIntervals(start: SequencePlace, end: SequencePlace): TInterval[];
 
 	/**
 	 * Gathers the interval results based on specified parameters.
@@ -30,8 +31,8 @@ export interface IOverlappingIntervalsIndex<TInterval extends ISerializableInter
 	gatherIterationResults(
 		results: TInterval[],
 		iteratesForward: boolean,
-		start?: number,
-		end?: number,
+		start?: SequencePlace,
+		end?: SequencePlace,
 	): void;
 }
 
@@ -58,8 +59,8 @@ export class OverlappingIntervalsIndex<TInterval extends ISerializableInterval>
 	public gatherIterationResults(
 		results: TInterval[],
 		iteratesForward: boolean,
-		start?: number,
-		end?: number,
+		start?: SequencePlace,
+		end?: SequencePlace,
 	): void {
 		if (this.intervalTree.intervals.isEmpty()) {
 			return;
@@ -79,8 +80,8 @@ export class OverlappingIntervalsIndex<TInterval extends ISerializableInterval>
 		} else {
 			const transientInterval: TInterval = this.helpers.create(
 				"transient",
-				start,
-				end,
+				start ?? "start",
+				end ?? "end",
 				this.client,
 				IntervalType.Transient,
 			);
@@ -137,8 +138,15 @@ export class OverlappingIntervalsIndex<TInterval extends ISerializableInterval>
 		}
 	}
 
-	public findOverlappingIntervals(start: number, end: number): TInterval[] {
-		if (end < start || this.intervalTree.intervals.isEmpty()) {
+	public findOverlappingIntervals(start: SequencePlace, end: SequencePlace): TInterval[] {
+		const { startPos, endPos } = endpointPosAndSide(start, end);
+
+		if (
+			startPos === undefined ||
+			endPos === undefined ||
+			endPos < startPos ||
+			this.intervalTree.intervals.isEmpty()
+		) {
 			return [];
 		}
 		const transientInterval = this.helpers.create(

package/src/intervalIndex/startpointInRangeIndex.ts

@@ -5,7 +5,6 @@
 /* eslint-disable import/no-deprecated */
 
 import { Client, PropertyAction, RedBlackTree } from "@fluidframework/merge-tree";
-import { assert } from "@fluidframework/core-utils";
 import {
 	IIntervalHelpers,
 	ISerializableInterval,
@@ -40,12 +39,7 @@ export class StartpointInRangeIndex<TInterval extends ISerializableInterval>
 		private readonly helpers: IIntervalHelpers<TInterval>,
 	) {
 		this.intervalTree = new RedBlackTree<TInterval, TInterval>((a: TInterval, b: TInterval) => {
-			assert(
-				typeof helpers.compareStarts === "function",
-				0x6d1 /* compareStarts does not exist in the helpers */,
-			);
-
-			const compareStartsResult = helpers.compareStarts(a, b);
+			const compareStartsResult = a.compareStart(b);
 			if (compareStartsResult !== 0) {
 				return compareStartsResult;
 			}

package/src/intervals/interval.ts

@@ -13,6 +13,8 @@ import {
 } from "@fluidframework/merge-tree";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import { assert } from "@fluidframework/core-utils";
+import { UsageError } from "@fluidframework/telemetry-utils";
+import { SequencePlace } from "../intervalCollection";
 import { IIntervalHelpers, ISerializableInterval, ISerializedInterval } from "./intervalUtils";
 
 const reservedIntervalIdKey = "intervalId";
@@ -185,9 +187,21 @@ export class Interval implements ISerializableInterval {
 	 * {@inheritDoc IInterval.modify}
 	 * @internal
 	 */
-	public modify(label: string, start: number, end: number, op?: ISequencedDocumentMessage) {
-		const startPos = start ?? this.start;
-		const endPos = end ?? this.end;
+	public modify(
+		label: string,
+		start?: SequencePlace,
+		end?: SequencePlace,
+		op?: ISequencedDocumentMessage,
+	) {
+		if (typeof start === "string" || typeof end === "string") {
+			throw new UsageError(
+				"The start and end positions of a plain interval may not be on the special endpoint segments.",
+			);
+		}
+
+		const startPos = typeof start === "number" ? start : start?.pos ?? this.start;
+		const endPos = typeof end === "number" ? end : end?.pos ?? this.end;
+
 		if (this.start === startPos && this.end === endPos) {
 			// Return undefined to indicate that no change is necessary.
 			return;
@@ -214,18 +228,25 @@ export class Interval implements ISerializableInterval {
 	}
 }
 
-export function createInterval(label: string, start: number, end: number): Interval {
+export function createInterval(label: string, start: SequencePlace, end: SequencePlace): Interval {
+	if (typeof start === "string" || typeof end === "string") {
+		throw new UsageError(
+			"The start and end positions of a plain interval may not be on the special endpoint segments.",
+		);
+	}
+
 	const rangeProp: PropertySet = {};
 
 	if (label && label.length > 0) {
 		rangeProp[reservedRangeLabelsKey] = [label];
 	}
 
-	return new Interval(start, end, rangeProp);
+	const startPos = typeof start === "number" ? start : start.pos;
+	const endPos = typeof end === "number" ? end : end.pos;
+
+	return new Interval(startPos, endPos, rangeProp);
 }
 
 export const intervalHelpers: IIntervalHelpers<Interval> = {
-	compareEnds: (a: Interval, b: Interval) => a.end - b.end,
-	compareStarts: (a: Interval, b: Interval) => a.start - b.start,
 	create: createInterval,
 };

package/src/intervals/intervalUtils.ts

@@ -12,6 +12,7 @@ import {
 	SlidingPreference,
 } from "@fluidframework/merge-tree";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+import { SequencePlace, Side } from "../intervalCollection";
 
 /**
  * Basic interval abstraction
@@ -47,10 +48,11 @@ export interface IInterval {
 	 */
 	modify(
 		label: string,
-		start: number | undefined,
-		end: number | undefined,
+		start: SequencePlace | undefined,
+		end: SequencePlace | undefined,
 		op?: ISequencedDocumentMessage,
 		localSeq?: number,
+		useNewSlidingBehavior?: boolean,
 	): IInterval | undefined;
 	/**
 	 * @returns whether this interval overlaps with `b`.
@@ -112,12 +114,17 @@ export interface ISerializedInterval {
 	 */
 	sequenceNumber: number;
 	/** Start position of the interval */
-	start: number;
+	start: number | "start" | "end";
 	/** End position of the interval */
-	end: number;
+	end: number | "start" | "end";
 	/** Interval type to create */
 	intervalType: IntervalType;
+	/**
+	 * The stickiness of this interval
+	 */
 	stickiness?: IntervalStickiness;
+	startSide?: Side;
+	endSide?: Side;
 	/** Any properties the interval has */
 	properties?: PropertySet;
 }
@@ -159,26 +166,33 @@ export type SerializedIntervalDelta = Omit<ISerializedInterval, "start" | "end"
  *
  * Intervals are of the format:
  *
- * [start, end, sequenceNumber, intervalType, properties, stickiness?]
+ * [
+ * start,
+ * end,
+ * sequenceNumber,
+ * intervalType,
+ * properties,
+ * stickiness?,
+ * startSide?,
+ * endSide?,
+ * ]
  */
 export type CompressedSerializedInterval =
-	| [number, number, number, IntervalType, PropertySet, IntervalStickiness]
-	| [number, number, number, IntervalType, PropertySet];
+	| [
+			number | "start" | "end",
+			number | "start" | "end",
+			number,
+			IntervalType,
+			PropertySet,
+			IntervalStickiness,
+	  ]
+	| [number | "start" | "end", number | "start" | "end", number, IntervalType, PropertySet];
 
 /**
  * @sealed
  * @deprecated The methods within have substitutions
  */
 export interface IIntervalHelpers<TInterval extends ISerializableInterval> {
-	/**
-	 * @deprecated Use the method `IInterval.compareEnd` instead
-	 */
-	compareEnds(a: TInterval, b: TInterval): number;
-
-	/**
-	 * @deprecated Use the method `IInterval.compareStart` instead
-	 */
-	compareStarts?(a: TInterval, b: TInterval): number;
 	/**
 	 *
 	 * @param label - label of the interval collection this interval is being added to. This parameter is
@@ -189,17 +203,20 @@ export interface IIntervalHelpers<TInterval extends ISerializableInterval> {
 	 * @param intervalType - Type of interval to create. Default is SlideOnRemove
 	 * @param op - If this create came from a remote client, op that created it. Default is undefined (i.e. local)
 	 * @param fromSnapshot - If this create came from loading a snapshot. Default is false.
-	 * @param stickiness - {@link (IntervalStickiness:type)} to apply to the added interval.
+	 * @param startSide - The side on which the start position lays. See
+	 * {@link SequencePlace} for additional context
+	 * @param endSide - The side on which the end position lays. See
+	 * {@link SequencePlace} for additional context
 	 */
 	create(
 		label: string,
-		start: number | undefined,
-		end: number | undefined,
+		start: SequencePlace | undefined,
+		end: SequencePlace | undefined,
 		client: Client | undefined,
 		intervalType: IntervalType,
 		op?: ISequencedDocumentMessage,
 		fromSnapshot?: boolean,
-		stickiness?: IntervalStickiness,
+		useNewSlidingBehavior?: boolean,
 	): TInterval;
 }
 
@@ -209,6 +226,8 @@ export interface IIntervalHelpers<TInterval extends ISerializableInterval> {
  *
  * Note that interval stickiness is currently an experimental feature and must
  * be explicitly enabled with the `intervalStickinessEnabled` flag
+ *
+ * @internal
  */
 export const IntervalStickiness = {
 	/**
@@ -240,19 +259,21 @@ export const IntervalStickiness = {
  *
  * Note that interval stickiness is currently an experimental feature and must
  * be explicitly enabled with the `intervalStickinessEnabled` flag
+ *
+ * @internal
  */
 export type IntervalStickiness = typeof IntervalStickiness[keyof typeof IntervalStickiness];
 
-export function endReferenceSlidingPreference(stickiness: IntervalStickiness): SlidingPreference {
-	// if any end stickiness, prefer sliding forwards
-	return (stickiness & IntervalStickiness.END) !== 0
+export function startReferenceSlidingPreference(stickiness: IntervalStickiness): SlidingPreference {
+	// if any start stickiness, prefer sliding backwards
+	return (stickiness & IntervalStickiness.START) === 0
 		? SlidingPreference.FORWARD
 		: SlidingPreference.BACKWARD;
 }
 
-export function startReferenceSlidingPreference(stickiness: IntervalStickiness): SlidingPreference {
-	// if any start stickiness, prefer sliding backwards
-	return (stickiness & IntervalStickiness.START) !== 0
+export function endReferenceSlidingPreference(stickiness: IntervalStickiness): SlidingPreference {
+	// if any end stickiness, prefer sliding forwards
+	return (stickiness & IntervalStickiness.END) === 0
 		? SlidingPreference.BACKWARD
 		: SlidingPreference.FORWARD;
 }