@fluidframework/sequence 2.0.0-dev-rc.1.0.0.228517 → 2.0.0-dev-rc.2.0.0.245554

package/src/{defaultMap.ts → intervalCollectionMap.ts}

@@ -5,66 +5,41 @@
 
 import { IFluidHandle } from "@fluidframework/core-interfaces";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
-import {
-	IFluidSerializer,
-	makeHandlesSerializable,
-	parseHandles,
-	ValueType,
-} from "@fluidframework/shared-object-base";
+import { IFluidSerializer, ValueType } from "@fluidframework/shared-object-base";
 import { TypedEventEmitter } from "@fluid-internal/client-utils";
 import { assert } from "@fluidframework/core-utils";
-import { makeSerializable, ValueTypeLocalValue } from "./localValues";
+import { makeSerializable, IntervalCollectionTypeLocalValue } from "./IntervalCollectionValues.js";
 import {
-	ISerializableValue,
-	ISerializedValue,
+	ISerializableIntervalCollection,
 	IValueChanged,
 	// eslint-disable-next-line import/no-deprecated
 	IValueOpEmitter,
-	IValueType,
+	IIntervalCollectionType,
 	ISharedDefaultMapEvents,
 	IMapMessageLocalMetadata,
 	SequenceOptions,
-	IValueTypeOperationValue,
-} from "./defaultMapInterfaces";
-import { SerializedIntervalDelta, IntervalDeltaOpType } from "./intervals";
+	IIntervalCollectionTypeOperationValue,
+} from "./intervalCollectionMapInterfaces.js";
+import {
+	SerializedIntervalDelta,
+	IntervalDeltaOpType,
+	type ISerializableInterval,
+} from "./intervals/index.js";
+import {
+	toSequencePlace,
+	toOptionalSequencePlace,
+	reservedIntervalIdKey,
+	type IntervalCollection,
+} from "./intervalCollection.js";
 
 function isMapOperation(op: unknown): op is IMapOperation {
 	return typeof op === "object" && op !== null && "type" in op && op.type === "act";
 }
-/**
- * Defines the means to process and submit a given op on a map.
- */
-interface IMapMessageHandler {
-	/**
-	 * Apply the given operation.
-	 * @param op - The map operation to apply
-	 * @param local - Whether the message originated from the local client
-	 * @param message - The full message. Not provided for stashed ops.
-	 * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
-	 * For messages from a remote client, this will be undefined.
-	 */
-	process(
-		op: IMapOperation,
-		local: boolean,
-		message: ISequencedDocumentMessage | undefined,
-		localOpMetadata: IMapMessageLocalMetadata,
-	): void;
-
-	/**
-	 * Communicate the operation to remote clients.
-	 * @param op - The map operation to submit
-	 */
-	submit(op: IMapOperation, localOpMetadata: IMapMessageLocalMetadata): void;
-
-	resubmit(op: IMapOperation, localOpMetadata: IMapMessageLocalMetadata): void;
-
-	getStashedOpLocalMetadata(op: IMapOperation): IMapMessageLocalMetadata;
-}
 
 /**
- * Describes an operation specific to a value type.
+ * Description of a map delta operation
  */
-export interface IMapValueTypeOperation {
+export interface IMapOperation {
 	/**
 	 * String identifier of the operation type.
 	 */
@@ -77,26 +52,15 @@ export interface IMapValueTypeOperation {
 
 	/**
 	 * Value of the operation, specific to the value type.
-	 * @alpha
 	 */
-	value: IValueTypeOperationValue;
+	value: IIntervalCollectionTypeOperationValue;
 }
-
-/**
- * Description of a map delta operation
- */
-export type IMapOperation = IMapValueTypeOperation;
-
 /**
  * Defines the in-memory object structure to be used for the conversion to/from serialized.
  * Directly used in JSON.stringify, direct result from JSON.parse
  */
 export interface IMapDataObjectSerializable {
-	[key: string]: ISerializableValue;
-}
-
-export interface IMapDataObjectSerialized {
-	[key: string]: ISerializedValue;
+	[key: string]: ISerializableIntervalCollection;
 }
 
 /**
@@ -106,7 +70,7 @@ export interface IMapDataObjectSerialized {
  * Creation of values is implicit on access (either via `get` or a remote op application referring to
  * a collection that wasn't previously known)
  */
-export class DefaultMap<T> {
+export class IntervalCollectionMap<T extends ISerializableInterval> {
 	/**
 	 * The number of key/value pairs stored in the map.
 	 */
@@ -117,12 +81,42 @@ export class DefaultMap<T> {
 	/**
 	 * Mapping of op types to message handlers.
 	 */
-	private readonly messageHandlers: ReadonlyMap<string, IMapMessageHandler> = new Map();
+	private readonly messageHandler = {
+		process: (
+			op: IMapOperation,
+			local: boolean,
+			message: ISequencedDocumentMessage,
+			localOpMetadata: IMapMessageLocalMetadata,
+		) => {
+			const localValue = this.data.get(op.key) ?? this.createCore(op.key, local);
+			const handler = localValue.getOpHandler(op.value.opName);
+			const previousValue = localValue.value;
+			const translatedValue = op.value.value as any;
+			handler.process(previousValue, translatedValue, local, message, localOpMetadata);
+			const event: IValueChanged = { key: op.key, previousValue };
+			this.eventEmitter.emit("valueChanged", event, local, message, this.eventEmitter);
+		},
+		submit: (op: IMapOperation, localOpMetadata: IMapMessageLocalMetadata) => {
+			this.submitMessage(op, localOpMetadata);
+		},
+		resubmit: (op: IMapOperation, localOpMetadata: IMapMessageLocalMetadata) => {
+			const localValue = this.data.get(op.key);
+
+			assert(localValue !== undefined, 0x3f8 /* Local value expected on resubmission */);
+
+			const handler = localValue.getOpHandler(op.value.opName);
+			const rebased = handler.rebase(localValue.value, op.value, localOpMetadata);
+			if (rebased !== undefined) {
+				const { rebasedOp, rebasedLocalOpMetadata } = rebased;
+				this.submitMessage({ ...op, value: rebasedOp }, rebasedLocalOpMetadata);
+			}
+		},
+	};
 
 	/**
 	 * The in-memory data the map is storing.
 	 */
-	private readonly data = new Map<string, ValueTypeLocalValue<T>>();
+	private readonly data = new Map<string, IntervalCollectionTypeLocalValue<T>>();
 
 	/**
 	 * Create a new default map.
@@ -136,15 +130,13 @@ export class DefaultMap<T> {
 		private readonly serializer: IFluidSerializer,
 		private readonly handle: IFluidHandle,
 		private readonly submitMessage: (
-			op: IMapValueTypeOperation,
+			op: IMapOperation,
 			localOpMetadata: IMapMessageLocalMetadata,
 		) => void,
-		private readonly type: IValueType<T>,
+		private readonly type: IIntervalCollectionType<T>,
 		private readonly options?: Partial<SequenceOptions>,
 		public readonly eventEmitter = new TypedEventEmitter<ISharedDefaultMapEvents>(),
-	) {
-		this.messageHandlers = this.getMessageHandlers();
-	}
+	) {}
 
 	/**
 	 * Get an iterator over the keys in this map.
@@ -154,26 +146,6 @@ export class DefaultMap<T> {
 		return this.data.keys();
 	}
 
-	/**
-	 * Get an iterator over the entries in this map.
-	 * @returns The iterator
-	 */
-	public entries(): IterableIterator<[string, any]> {
-		const localEntriesIterator = this.data.entries();
-		const iterator = {
-			next(): IteratorResult<[string, any]> {
-				const nextVal = localEntriesIterator.next();
-				return nextVal.done
-					? { value: undefined, done: true }
-					: { value: [nextVal.value[0], nextVal.value[1].value], done: false }; // Unpack the stored value
-			},
-			[Symbol.iterator]() {
-				return this;
-			},
-		};
-		return iterator;
-	}
-
 	/**
 	 * Get an iterator over the values in this map.
 	 * @returns The iterator
@@ -193,56 +165,15 @@ export class DefaultMap<T> {
 		};
 		return iterator;
 	}
-
-	/**
-	 * Get an iterator over the entries in this map.
-	 * @returns The iterator
-	 */
-	public [Symbol.iterator](): IterableIterator<[string, any]> {
-		return this.entries();
-	}
-
-	/**
-	 * Executes the given callback on each entry in the map.
-	 * @param callbackFn - Callback function
-	 */
-	public forEach(callbackFn: (value: any, key: string, map: Map<string, any>) => void): void {
-		this.data.forEach((localValue, key, m) => {
-			callbackFn(localValue.value, key, m);
-		});
-	}
-
 	/**
 	 * {@inheritDoc ISharedMap.get}
 	 */
-	public get(key: string): T {
+	public get(key: string): IntervalCollection<T> {
 		const localValue = this.data.get(key) ?? this.createCore(key, true);
 
 		return localValue.value;
 	}
 
-	/**
-	 * Check if a key exists in the map.
-	 * @param key - The key to check
-	 * @returns True if the key exists, false otherwise
-	 */
-	public has(key: string): boolean {
-		return this.data.has(key);
-	}
-
-	/**
-	 * Serializes the data stored in the shared map to a JSON string
-	 * @param serializer - The serializer to use to serialize handles in its values.
-	 * @returns A JSON string containing serialized map data
-	 */
-	public getSerializedStorage(serializer: IFluidSerializer): IMapDataObjectSerialized {
-		const serializableMapData: IMapDataObjectSerialized = {};
-		this.data.forEach((localValue, key) => {
-			serializableMapData[key] = localValue.makeSerialized(serializer, this.handle);
-		});
-		return serializableMapData;
-	}
-
 	public getSerializableStorage(serializer: IFluidSerializer): IMapDataObjectSerializable {
 		const serializableMapData: IMapDataObjectSerializable = {};
 		this.data.forEach((localValue, key) => {
@@ -257,10 +188,13 @@ export class DefaultMap<T> {
 
 	/**
 	 * Populate the kernel with the given map data.
-	 * @param data - A JSON string containing serialized map data
+	 *
+	 * @param serialized - A JSON string containing serialized map data
 	 */
-	public populateFromSerializable(json: IMapDataObjectSerializable): void {
-		for (const [key, serializable] of Object.entries(json)) {
+	public populate(serialized: string): void {
+		const parsed = this.serializer.parse(serialized) as IMapDataObjectSerializable;
+
+		for (const [key, serializable] of Object.entries(parsed)) {
 			// Back-compat: legacy documents may have handles to an intervalCollection map kernel.
 			// These collections should be empty, and ValueTypes are no longer supported.
 			if (
@@ -285,10 +219,6 @@ export class DefaultMap<T> {
 		}
 	}
 
-	public populate(json: string): void {
-		this.populateFromSerializable(JSON.parse(json) as IMapDataObjectSerializable);
-	}
-
 	/**
 	 * Submit the given op if a handler is registered.
 	 * @param op - The operation to attempt to submit
@@ -297,25 +227,50 @@ export class DefaultMap<T> {
 	 * also sent if we are asked to resubmit the message.
 	 * @returns True if the operation was submitted, false otherwise.
 	 */
-	public tryResubmitMessage(
-		op: IMapOperation,
-		localOpMetadata: IMapMessageLocalMetadata,
-	): boolean {
-		const type: string = op.type;
-		const handler = this.messageHandlers.get(type);
-		if (handler !== undefined) {
-			handler.resubmit(op, localOpMetadata);
+	public tryResubmitMessage(op: unknown, localOpMetadata: IMapMessageLocalMetadata): boolean {
+		if (isMapOperation(op)) {
+			this.messageHandler.resubmit(op, localOpMetadata);
 			return true;
 		}
 		return false;
 	}
 
-	public tryGetStashedOpLocalMetadata(op: unknown): IMapMessageLocalMetadata | undefined {
-		if (isMapOperation(op) && this.messageHandlers.has(op.type)) {
-			// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-			return this.messageHandlers.get(op.type)!.getStashedOpLocalMetadata(op);
+	public tryApplyStashedOp(op: unknown): boolean {
+		if (isMapOperation(op)) {
+			const { value, key } = op;
+			const map = this.get(key);
+
+			switch (value.opName) {
+				case "add": {
+					map.add({
+						// Todo: we should improve typing so we know add ops always have start and end
+						// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+						start: toSequencePlace(value.value.start!, value.value.startSide),
+						// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+						end: toSequencePlace(value.value.end!, value.value.endSide),
+						props: value.value.properties,
+					});
+					return true;
+				}
+				case "change": {
+					const { [reservedIntervalIdKey]: id, ...props } = value.value.properties ?? {};
+					map.change(id, {
+						start: toOptionalSequencePlace(value.value.start, value.value.startSide),
+						end: toOptionalSequencePlace(value.value.end, value.value.endSide),
+						props,
+					});
+					return true;
+				}
+				case "delete": {
+					const { [reservedIntervalIdKey]: id } = value.value.properties ?? {};
+					map.removeIntervalById(id);
+					return true;
+				}
+				default:
+					throw new Error("unknown ops should not be stashed");
+			}
 		}
-		return undefined;
+		return false;
 	}
 
 	/**
@@ -327,14 +282,18 @@ export class DefaultMap<T> {
 	 * @returns True if the operation was processed, false otherwise.
 	 */
 	public tryProcessMessage(
-		op: IMapOperation,
+		op: unknown,
 		local: boolean,
-		message: ISequencedDocumentMessage | undefined,
+		message: ISequencedDocumentMessage,
 		localOpMetadata: unknown,
 	): boolean {
-		const handler = this.messageHandlers.get(op.type);
-		if (handler !== undefined) {
-			handler.process(op, local, message, localOpMetadata as IMapMessageLocalMetadata);
+		if (isMapOperation(op)) {
+			this.messageHandler.process(
+				op,
+				local,
+				message,
+				localOpMetadata as IMapMessageLocalMetadata,
+			);
 			return true;
 		}
 		return false;
@@ -346,8 +305,8 @@ export class DefaultMap<T> {
 	 * @param key - The key being initialized
 	 * @param local - Whether the message originated from the local client
 	 */
-	private createCore(key: string, local: boolean): ValueTypeLocalValue<T> {
-		const localValue = new ValueTypeLocalValue(
+	private createCore(key: string, local: boolean): IntervalCollectionTypeLocalValue<T> {
+		const localValue = new IntervalCollectionTypeLocalValue(
 			this.type.factory.load(this.makeMapValueOpEmitter(key), undefined, this.options),
 			this.type,
 		);
@@ -368,74 +327,26 @@ export class DefaultMap<T> {
 	 * @param serializable - The remote information that we can convert into a real object
 	 * @returns The local value that was produced
 	 */
-	private makeLocal(key: string, serializable: ISerializableValue): ValueTypeLocalValue<T> {
+	private makeLocal(
+		key: string,
+		serializable: ISerializableIntervalCollection,
+	): IntervalCollectionTypeLocalValue<T> {
 		assert(
 			serializable.type !== ValueType[ValueType.Plain] &&
 				serializable.type !== ValueType[ValueType.Shared],
 			0x2e1 /* "Support for plain value types removed." */,
 		);
 
-		serializable.value = parseHandles(serializable.value, this.serializer);
 		const localValue = this.type.factory.load(
 			this.makeMapValueOpEmitter(key),
 			serializable.value,
 			this.options,
 		);
-		return new ValueTypeLocalValue(localValue, this.type);
-	}
-
-	/**
-	 * Get the message handlers for the map.
-	 * @returns A map of string op names to IMapMessageHandlers for those ops
-	 */
-	private getMessageHandlers() {
-		const messageHandlers = new Map<string, IMapMessageHandler>();
-		// Ops with type "act" describe actions taken by custom value type handlers of whatever item is
-		// being addressed.  These custom handlers can be retrieved from the ValueTypeLocalValue which has
-		// stashed its valueType (and therefore its handlers).  We also emit a valueChanged for anyone
-		// watching for manipulations of that item.
-		messageHandlers.set("act", {
-			process: (op: IMapValueTypeOperation, local, message, localOpMetadata) => {
-				const localValue = this.data.get(op.key) ?? this.createCore(op.key, local);
-				const handler = localValue.getOpHandler(op.value.opName);
-				const previousValue = localValue.value;
-				const translatedValue = parseHandles(op.value.value, this.serializer);
-				handler.process(previousValue, translatedValue, local, message, localOpMetadata);
-				const event: IValueChanged = { key: op.key, previousValue };
-				this.eventEmitter.emit("valueChanged", event, local, message, this.eventEmitter);
-			},
-			submit: (op: IMapValueTypeOperation, localOpMetadata: IMapMessageLocalMetadata) => {
-				this.submitMessage(op, localOpMetadata);
-			},
-			resubmit: (op: IMapValueTypeOperation, localOpMetadata: IMapMessageLocalMetadata) => {
-				const localValue = this.data.get(op.key);
-
-				assert(localValue !== undefined, 0x3f8 /* Local value expected on resubmission */);
-
-				const handler = localValue.getOpHandler(op.value.opName);
-				const rebased = handler.rebase(localValue.value, op.value, localOpMetadata);
-				if (rebased !== undefined) {
-					const { rebasedOp, rebasedLocalOpMetadata } = rebased;
-					this.submitMessage({ ...op, value: rebasedOp }, rebasedLocalOpMetadata);
-				}
-			},
-			getStashedOpLocalMetadata: (op: IMapValueTypeOperation): IMapMessageLocalMetadata => {
-				const localValue = this.data.get(op.key) ?? this.createCore(op.key, true);
-				assert(
-					localValue !== undefined,
-					0x879 /* Local value expected on applying stashed op */,
-				);
-				const handler = localValue.getOpHandler(op.value.opName);
-				return handler.applyStashedOp(localValue.value, op.value);
-			},
-		});
-
-		return messageHandlers;
+		return new IntervalCollectionTypeLocalValue(localValue, this.type);
 	}
 
 	/**
 	 * Create an emitter for a value type to emit ops from the given key.
-	 * @alpha
 	 * @param key - The key of the map that the value type will be stored on
 	 * @returns A value op emitter for the given key
 	 */
@@ -448,14 +359,12 @@ export class DefaultMap<T> {
 			params: SerializedIntervalDelta,
 			localOpMetadata: IMapMessageLocalMetadata,
 		): void => {
-			const translatedParams = makeHandlesSerializable(params, this.serializer, this.handle);
-
-			const op: IMapValueTypeOperation = {
+			const op: IMapOperation = {
 				key,
 				type: "act",
 				value: {
 					opName,
-					value: translatedParams,
+					value: params,
 				},
 			};
 

package/src/{defaultMapInterfaces.ts → intervalCollectionMapInterfaces.ts}

@@ -11,7 +11,9 @@ import {
 	IntervalOpType,
 	SerializedIntervalDelta,
 	IntervalDeltaOpType,
-} from "./intervals";
+	type ISerializableInterval,
+} from "./intervals/index.js";
+import type { IntervalCollection } from "./intervalCollection.js";
 
 /**
  * Type of "valueChanged" event parameter.
@@ -92,32 +94,34 @@ export interface SequenceOptions {
  * A value factory is used to serialize/deserialize value types to a map
  * @alpha
  */
-export interface IValueFactory<T> {
+export interface IIntervalCollectionFactory<T extends ISerializableInterval> {
 	/**
 	 * Create a new value type.  Used both in creation of new value types, as well as in loading existing ones
 	 * from remote.
 	 * @param emitter - Emitter object that the created value type will use to emit operations
 	 * @param raw - Initialization parameters as defined by the value type
 	 * @returns The new value type
-	 * @alpha
 	 */
-	load(emitter: IValueOpEmitter, raw: any, options?: Partial<SequenceOptions>): T;
+	load(
+		emitter: IValueOpEmitter,
+		raw: any,
+		options?: Partial<SequenceOptions>,
+	): IntervalCollection<T>;
 
 	/**
 	 * Given a value type, provides a JSONable form of its data to be used for snapshotting.  This data must be
 	 * loadable using the load method of its factory.
 	 * @param value - The value type to serialize
 	 * @returns The JSONable form of the value type
-	 * @alpha
 	 */
-	store(value: T): any;
+	store(value: IntervalCollection<T>): any;
 }
 
 /**
  * Defines an operation that a value type is able to handle.
  * @alpha
  */
-export interface IValueOperation<T> {
+export interface IIntervalCollectionOperation<T extends ISerializableInterval> {
 	/**
 	 * Performs the actual processing on the incoming operation.
 	 * @param value - The current value stored at the given key, which should be the value type
@@ -125,10 +129,9 @@ export interface IValueOperation<T> {
 	 * @param local - Whether the operation originated from this client
 	 * @param message - The operation itself
 	 * @param localOpMetadata - any local metadata submitted by `IValueOpEmitter.emit`.
-	 * @alpha
 	 */
 	process(
-		value: T,
+		value: IntervalCollection<T>,
 		params: ISerializedInterval,
 		local: boolean,
 		message: ISequencedDocumentMessage | undefined,
@@ -144,37 +147,35 @@ export interface IValueOperation<T> {
 	 * @returns A rebased version of the op and any local metadata that should be submitted with it.
 	 */
 	rebase(
-		value: T,
-		op: IValueTypeOperationValue,
+		value: IntervalCollection<T>,
+		op: IIntervalCollectionTypeOperationValue,
 		localOpMetadata: IMapMessageLocalMetadata,
 	):
-		| { rebasedOp: IValueTypeOperationValue; rebasedLocalOpMetadata: IMapMessageLocalMetadata }
+		| {
+				rebasedOp: IIntervalCollectionTypeOperationValue;
+				rebasedLocalOpMetadata: IMapMessageLocalMetadata;
+		  }
 		| undefined;
-
-	applyStashedOp(value: T, op: IValueTypeOperationValue): IMapMessageLocalMetadata;
 }
 
 /**
  * Defines a value type that can be registered on a container type.
  */
-export interface IValueType<T> {
+export interface IIntervalCollectionType<T extends ISerializableInterval> {
 	/**
 	 * Name of the value type.
-	 * @alpha
 	 */
 	name: string;
 
 	/**
 	 * Factory method used to convert to/from a JSON form of the type.
-	 * @alpha
 	 */
-	factory: IValueFactory<T>;
+	factory: IIntervalCollectionFactory<T>;
 
 	/**
 	 * Operations that can be applied to the value type.
-	 * @alpha
 	 */
-	ops: Map<IntervalOpType, IValueOperation<T>>;
+	ops: Map<IntervalOpType, IIntervalCollectionOperation<T>>;
 }
 
 export interface ISharedDefaultMapEvents extends ISharedObjectEvents {
@@ -195,7 +196,7 @@ export interface ISharedDefaultMapEvents extends ISharedObjectEvents {
  * The DefaultMap implementation for sequence has been specialized to only support a single ValueType, which serializes
  * and deserializes via .store() and .load().
  */
-export interface ISerializableValue {
+export interface ISerializableIntervalCollection {
 	/**
 	 * A type annotation to help indicate how the value serializes.
 	 */
@@ -207,7 +208,7 @@ export interface ISerializableValue {
 	value: any;
 }
 
-export interface ISerializedValue {
+export interface ISerializedIntervalCollection {
 	/**
 	 * A type annotation to help indicate how the value serializes.
 	 */
@@ -228,7 +229,7 @@ export interface ISerializedValue {
  * it just describes an operation to be applied to an already-in-memory value.
  * @alpha
  */
-export interface IValueTypeOperationValue {
+export interface IIntervalCollectionTypeOperationValue {
 	/**
 	 * The name of the operation.
 	 */

package/src/intervalIndex/endpointInRangeIndex.ts

@@ -11,10 +11,10 @@ import {
 	IntervalType,
 	SequenceInterval,
 	sequenceIntervalHelpers,
-} from "../intervals";
-import { SharedString } from "../sharedString";
-import { IntervalIndex } from "./intervalIndex";
-import { HasComparisonOverride, compareOverrideables, forceCompare } from "./intervalIndexUtils";
+} from "../intervals/index.js";
+import { SharedString } from "../sharedString.js";
+import { IntervalIndex } from "./intervalIndex.js";
+import { HasComparisonOverride, compareOverrideables, forceCompare } from "./intervalIndexUtils.js";
 
 /**
  * Collection of intervals.

package/src/intervalIndex/endpointIndex.ts

@@ -11,9 +11,9 @@ import {
 	IntervalType,
 	SequenceInterval,
 	sequenceIntervalHelpers,
-} from "../intervals";
-import { SharedString } from "../sharedString";
-import { IntervalIndex } from "./intervalIndex";
+} from "../intervals/index.js";
+import { SharedString } from "../sharedString.js";
+import { IntervalIndex } from "./intervalIndex.js";
 
 /**
  * @internal

package/src/intervalIndex/idIntervalIndex.ts

@@ -4,10 +4,9 @@
  */
 
 import { assert } from "@fluidframework/core-utils";
-import { ISerializableInterval } from "../intervals";
-import { IntervalIndex } from "./intervalIndex";
-
-const reservedIntervalIdKey = "intervalId";
+import { ISerializableInterval } from "../intervals/index.js";
+import { reservedIntervalIdKey } from "../intervalCollection.js";
+import { IntervalIndex } from "./intervalIndex.js";
 
 /**
  * @internal