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

package/src/intervalIndex/endpointInRangeIndex.ts

@@ -2,9 +2,17 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
+/* eslint-disable import/no-deprecated */
 
 import { Client, PropertyAction, RedBlackTree } from "@fluidframework/merge-tree";
-import { IIntervalHelpers, ISerializableInterval, IntervalType } from "../intervals";
+import {
+	IIntervalHelpers,
+	ISerializableInterval,
+	IntervalType,
+	SequenceInterval,
+	sequenceIntervalHelpers,
+} from "../intervals";
+import { SharedString } from "../sharedString";
 import { IntervalIndex } from "./intervalIndex";
 import { HasComparisonOverride, compareOverrideables, forceCompare } from "./intervalIndexUtils";
 
@@ -18,20 +26,20 @@ export interface IEndpointInRangeIndex<TInterval extends ISerializableInterval>
 	/**
 	 * @returns an array of all intervals contained in this collection whose endpoints locate in the range [start, end] (includes both ends)
 	 */
-	findIntervalsWithEndpointInRange(start: number, end: number);
+	findIntervalsWithEndpointInRange(start: number, end: number): TInterval[];
 }
 
-class EndpointInRangeIndex<TInterval extends ISerializableInterval>
+export class EndpointInRangeIndex<TInterval extends ISerializableInterval>
 	implements IEndpointInRangeIndex<TInterval>
 {
 	private readonly intervalTree;
 
 	constructor(
-		private readonly helpers: IIntervalHelpers<TInterval>,
 		private readonly client: Client,
+		private readonly helpers: IIntervalHelpers<TInterval>,
 	) {
 		this.intervalTree = new RedBlackTree<TInterval, TInterval>((a: TInterval, b: TInterval) => {
-			const compareEndsResult = helpers.compareEnds(a, b);
+			const compareEndsResult = a.compareEnd(b);
 			if (compareEndsResult !== 0) {
 				return compareEndsResult;
 			}
@@ -61,7 +69,7 @@ class EndpointInRangeIndex<TInterval extends ISerializableInterval>
 		this.intervalTree.remove(interval);
 	}
 
-	public findIntervalsWithEndpointInRange(start: number, end: number) {
+	public findIntervalsWithEndpointInRange(start: number, end: number): TInterval[] {
 		if (start <= 0 || start > end || this.intervalTree.isEmpty()) {
 			return [];
 		}
@@ -96,9 +104,9 @@ class EndpointInRangeIndex<TInterval extends ISerializableInterval>
 	}
 }
 
-export function createEndpointInRangeIndex<TInterval extends ISerializableInterval>(
-	helpers: IIntervalHelpers<TInterval>,
-	client: Client,
-): IEndpointInRangeIndex<TInterval> {
-	return new EndpointInRangeIndex<TInterval>(helpers, client);
+export function createEndpointInRangeIndex(
+	sharedString: SharedString,
+): IEndpointInRangeIndex<SequenceInterval> {
+	const client = (sharedString as unknown as { client: Client }).client;
+	return new EndpointInRangeIndex<SequenceInterval>(client, sequenceIntervalHelpers);
 }

package/src/intervalIndex/endpointIndex.ts

@@ -2,9 +2,17 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
+/* eslint-disable import/no-deprecated */
 
 import { Client, RedBlackTree } from "@fluidframework/merge-tree";
-import { IIntervalHelpers, ISerializableInterval, IntervalType } from "../intervals";
+import {
+	IIntervalHelpers,
+	ISerializableInterval,
+	IntervalType,
+	SequenceInterval,
+	sequenceIntervalHelpers,
+} from "../intervals";
+import { SharedString } from "../sharedString";
 import { IntervalIndex } from "./intervalIndex";
 
 export interface IEndpointIndex<TInterval extends ISerializableInterval>
@@ -22,15 +30,16 @@ export interface IEndpointIndex<TInterval extends ISerializableInterval>
 	nextInterval(pos: number): TInterval | undefined;
 }
 
-class EndpointIndex<TInterval extends ISerializableInterval> implements IEndpointIndex<TInterval> {
+export class EndpointIndex<TInterval extends ISerializableInterval>
+	implements IEndpointIndex<TInterval>
+{
 	private readonly endIntervalTree: RedBlackTree<TInterval, TInterval>;
 
 	constructor(
 		private readonly client: Client,
 		private readonly helpers: IIntervalHelpers<TInterval>,
 	) {
-		// eslint-disable-next-line @typescript-eslint/unbound-method
-		this.endIntervalTree = new RedBlackTree<TInterval, TInterval>(helpers.compareEnds);
+		this.endIntervalTree = new RedBlackTree<TInterval, TInterval>((a, b) => a.compareEnd(b));
 	}
 
 	public previousInterval(pos: number): TInterval | undefined {
@@ -70,9 +79,7 @@ class EndpointIndex<TInterval extends ISerializableInterval> implements IEndpoin
 	}
 }
 
-export function createEndpointIndex<TInterval extends ISerializableInterval>(
-	client: Client,
-	helpers: IIntervalHelpers<TInterval>,
-): IEndpointIndex<TInterval> {
-	return new EndpointIndex<TInterval>(client, helpers);
+export function createEndpointIndex(sharedString: SharedString): IEndpointIndex<SequenceInterval> {
+	const client = (sharedString as unknown as { client: Client }).client;
+	return new EndpointIndex<SequenceInterval>(client, sequenceIntervalHelpers);
 }

package/src/intervalIndex/idIntervalIndex.ts

@@ -19,7 +19,7 @@ export interface IIdIntervalIndex<TInterval extends ISerializableInterval>
 class IdIntervalIndex<TInterval extends ISerializableInterval>
 	implements IIdIntervalIndex<TInterval>, Iterable<TInterval>
 {
-	private readonly intervalIdMap: Map<string, TInterval> = new Map();
+	private readonly intervalIdMap = new Map<string, TInterval>();
 
 	public add(interval: TInterval) {
 		const id = interval.getIntervalId();

package/src/intervalIndex/index.ts

@@ -5,12 +5,21 @@
 
 export { IntervalIndex } from "./intervalIndex";
 export { IIdIntervalIndex, createIdIntervalIndex } from "./idIntervalIndex";
-export { IEndpointIndex, createEndpointIndex } from "./endpointIndex";
-export { IEndpointInRangeIndex, createEndpointInRangeIndex } from "./endpointInRangeIndex";
-export { IStartpointInRangeIndex, createStartpointInRangeIndex } from "./startpointInRangeIndex";
+export { IEndpointIndex, createEndpointIndex, EndpointIndex } from "./endpointIndex";
+export {
+	IEndpointInRangeIndex,
+	createEndpointInRangeIndex,
+	EndpointInRangeIndex,
+} from "./endpointInRangeIndex";
+export {
+	IStartpointInRangeIndex,
+	createStartpointInRangeIndex,
+	StartpointInRangeIndex,
+} from "./startpointInRangeIndex";
 export { SequenceIntervalIndexes } from "./sequenceIntervalIndexes";
 export {
 	IOverlappingIntervalsIndex,
 	createOverlappingIntervalsIndex,
+	OverlappingIntervalsIndex,
 } from "./overlappingIntervalsIndex";
 export { createOverlappingSequenceIntervalsIndex } from "./overlappingSequenceIntervalsIndex";

package/src/intervalIndex/intervalIndex.ts

@@ -17,14 +17,14 @@ import { ISerializableInterval } from "../intervals";
 export interface IntervalIndex<TInterval extends ISerializableInterval> {
 	/**
 	 * Adds an interval to the index.
-	 * @remarks - Application code should never need to invoke this method on their index for production scenarios:
+	 * @remarks Application code should never need to invoke this method on their index for production scenarios:
 	 * Fluid handles adding and removing intervals from an index in response to sequence or interval changes.
 	 */
 	add(interval: TInterval): void;
 
 	/**
 	 * Removes an interval from the index.
-	 * @remarks - Application code should never need to invoke this method on their index for production scenarios:
+	 * @remarks Application code should never need to invoke this method on their index for production scenarios:
 	 * Fluid handles adding and removing intervals from an index in response to sequence or interval changes.
 	 */
 	remove(interval: TInterval): void;

package/src/intervalIndex/overlappingIntervalsIndex.ts

@@ -2,10 +2,19 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
+/* eslint-disable import/no-deprecated */
 
 import { Client } from "@fluidframework/merge-tree";
-import { IntervalType, IIntervalHelpers, ISerializableInterval } from "../intervals";
+import {
+	IntervalType,
+	IIntervalHelpers,
+	ISerializableInterval,
+	sequenceIntervalHelpers,
+	SequenceInterval,
+} 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>
@@ -14,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.
@@ -22,8 +31,8 @@ export interface IOverlappingIntervalsIndex<TInterval extends ISerializableInter
 	gatherIterationResults(
 		results: TInterval[],
 		iteratesForward: boolean,
-		start?: number,
-		end?: number,
+		start?: SequencePlace,
+		end?: SequencePlace,
 	): void;
 }
 
@@ -50,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;
@@ -71,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,
 			);
@@ -129,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(
@@ -154,9 +170,9 @@ export class OverlappingIntervalsIndex<TInterval extends ISerializableInterval>
 	}
 }
 
-export function createOverlappingIntervalsIndex<TInterval extends ISerializableInterval>(
-	client: Client,
-	helpers: IIntervalHelpers<TInterval>,
-): IOverlappingIntervalsIndex<TInterval> {
-	return new OverlappingIntervalsIndex<TInterval>(client, helpers);
+export function createOverlappingIntervalsIndex(
+	sharedString: SharedString,
+): IOverlappingIntervalsIndex<SequenceInterval> {
+	const client = (sharedString as unknown as { client: Client }).client;
+	return new OverlappingIntervalsIndex<SequenceInterval>(client, sequenceIntervalHelpers);
 }

package/src/intervalIndex/overlappingSequenceIntervalsIndex.ts

@@ -2,6 +2,7 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
+/* eslint-disable import/no-deprecated */
 
 import {
 	Client,
@@ -16,6 +17,7 @@ import {
 	SequenceInterval,
 	createPositionReferenceFromSegoff,
 } from "../intervals";
+import { SharedString } from "../sharedString";
 import { SequenceIntervalIndexes } from "./sequenceIntervalIndexes";
 import { OverlappingIntervalsIndex } from "./overlappingIntervalsIndex";
 
@@ -65,7 +67,8 @@ class OverlappingSequenceIntervalsIndex
 }
 
 export function createOverlappingSequenceIntervalsIndex(
-	client: Client,
+	sharedString: SharedString,
 ): SequenceIntervalIndexes.Overlapping {
+	const client = (sharedString as unknown as { client: Client }).client;
 	return new OverlappingSequenceIntervalsIndex(client);
 }

package/src/intervalIndex/sequenceIntervalIndexes.ts

@@ -27,6 +27,6 @@ export namespace SequenceIntervalIndexes {
 		findOverlappingIntervalsBySegoff(
 			startSegoff: { segment: ISegment | undefined; offset: number | undefined },
 			endSegoff: { segment: ISegment | undefined; offset: number | undefined },
-		);
+		): Iterable<SequenceInterval>;
 	}
 }

package/src/intervalIndex/startpointInRangeIndex.ts

@@ -2,10 +2,17 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
+/* eslint-disable import/no-deprecated */
 
 import { Client, PropertyAction, RedBlackTree } from "@fluidframework/merge-tree";
-import { assert } from "@fluidframework/core-utils";
-import { IIntervalHelpers, ISerializableInterval, IntervalType } from "../intervals";
+import {
+	IIntervalHelpers,
+	ISerializableInterval,
+	IntervalType,
+	SequenceInterval,
+	sequenceIntervalHelpers,
+} from "../intervals";
+import { SharedString } from "../sharedString";
 import { IntervalIndex } from "./intervalIndex";
 import { HasComparisonOverride, compareOverrideables, forceCompare } from "./intervalIndexUtils";
 
@@ -19,25 +26,20 @@ export interface IStartpointInRangeIndex<TInterval extends ISerializableInterval
 	/**
 	 * @returns an array of all intervals contained in this collection whose startpoints locate in the range [start, end] (includes both ends)
 	 */
-	findIntervalsWithStartpointInRange(start: number, end: number);
+	findIntervalsWithStartpointInRange(start: number, end: number): TInterval[];
 }
 
-class StartpointInRangeIndex<TInterval extends ISerializableInterval>
+export class StartpointInRangeIndex<TInterval extends ISerializableInterval>
 	implements IStartpointInRangeIndex<TInterval>
 {
 	private readonly intervalTree;
 
 	constructor(
-		private readonly helpers: IIntervalHelpers<TInterval>,
 		private readonly client: Client,
+		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;
 			}
@@ -66,7 +68,7 @@ class StartpointInRangeIndex<TInterval extends ISerializableInterval>
 		this.intervalTree.remove(interval);
 	}
 
-	public findIntervalsWithStartpointInRange(start: number, end: number) {
+	public findIntervalsWithStartpointInRange(start: number, end: number): TInterval[] {
 		if (start <= 0 || start > end || this.intervalTree.isEmpty()) {
 			return [];
 		}
@@ -101,9 +103,9 @@ class StartpointInRangeIndex<TInterval extends ISerializableInterval>
 	}
 }
 
-export function createStartpointInRangeIndex<TInterval extends ISerializableInterval>(
-	helpers: IIntervalHelpers<TInterval>,
-	client: Client,
-): IStartpointInRangeIndex<TInterval> {
-	return new StartpointInRangeIndex<TInterval>(helpers, client);
+export function createStartpointInRangeIndex(
+	sharedString: SharedString,
+): IStartpointInRangeIndex<SequenceInterval> {
+	const client = (sharedString as unknown as { client: Client }).client;
+	return new StartpointInRangeIndex<SequenceInterval>(client, sequenceIntervalHelpers);
 }

package/src/intervals/interval.ts

@@ -2,6 +2,7 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
+/* eslint-disable import/no-deprecated */
 
 import {
 	ICombiningOp,
@@ -12,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";
@@ -60,7 +63,7 @@ export class Interval implements ISerializableInterval {
 	 * Adds an auxiliary set of properties to this interval.
 	 * These properties can be recovered using `getAdditionalPropertySets`
 	 * @param props - set of properties to add
-	 * @remarks - This gets called as part of the default conflict resolver for `IIntervalCollection<Interval>`
+	 * @remarks This gets called as part of the default conflict resolver for `IIntervalCollection<Interval>`
 	 * (i.e. non-sequence-based interval collections). However, the additional properties don't get serialized.
 	 * This functionality seems half-baked.
 	 */
@@ -184,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;
@@ -213,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,8 @@ import {
 	SlidingPreference,
 } from "@fluidframework/merge-tree";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
+import { SequencePlace, Side } from "../intervalCollection";
+
 /**
  * Basic interval abstraction
  */
@@ -46,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`.
@@ -105,18 +108,23 @@ export interface ISerializedInterval {
 	/**
 	 * Sequence number at which `start` and `end` should be interpreted
 	 *
-	 * @remarks - It's unclear that this is necessary to store here.
+	 * @remarks It's unclear that this is necessary to store here.
 	 * This should just be the refSeq on the op that modified the interval, which should be available via other means.
 	 * At the time of writing, it's not plumbed through to the reconnect/rebase code, however, which does need it.
 	 */
 	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;
 }
@@ -138,7 +146,7 @@ export interface ISerializableInterval extends IInterval {
 	 * Gets the id associated with this interval.
 	 * When the interval is used as part of an interval collection, this id can be used to modify or remove the
 	 * interval.
-	 * @remarks - This signature includes `undefined` strictly for backwards-compatibility reasons, as older versions
+	 * @remarks This signature includes `undefined` strictly for backwards-compatibility reasons, as older versions
 	 * of Fluid didn't always write interval ids.
 	 */
 	getIntervalId(): string | undefined;
@@ -158,25 +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
@@ -187,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;
 }
 
@@ -207,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 = {
 	/**
@@ -238,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;
 }