@fluidframework/sequence 2.0.0-internal.3.0.2 → 2.0.0-internal.3.2.0

package/src/sequenceDeltaEvent.ts

@@ -5,16 +5,16 @@
 
 import { assert } from "@fluidframework/common-utils";
 import {
-    Client,
-    IMergeTreeDeltaCallbackArgs,
-    IMergeTreeDeltaOpArgs,
-    IMergeTreeMaintenanceCallbackArgs,
-    ISegment,
-    MergeTreeDeltaOperationType,
-    MergeTreeDeltaOperationTypes,
-    MergeTreeMaintenanceType,
-    PropertySet,
-    SortedSegmentSet,
+	Client,
+	IMergeTreeDeltaCallbackArgs,
+	IMergeTreeDeltaOpArgs,
+	IMergeTreeMaintenanceCallbackArgs,
+	ISegment,
+	MergeTreeDeltaOperationType,
+	MergeTreeDeltaOperationTypes,
+	MergeTreeMaintenanceType,
+	PropertySet,
+	SortedSegmentSet,
 } from "@fluidframework/merge-tree";
 
 /**
@@ -24,71 +24,75 @@ import {
  * point in time at which the operation was applied.
  * They will not take into any future modifications performed to the underlying sequence and merge tree.
  */
-export abstract class SequenceEvent<TOperation extends MergeTreeDeltaOperationTypes = MergeTreeDeltaOperationTypes> {
-    public readonly deltaOperation: TOperation;
-    private readonly sortedRanges: Lazy<SortedSegmentSet<ISequenceDeltaRange<TOperation>>>;
-    private readonly pFirst: Lazy<ISequenceDeltaRange<TOperation>>;
-    private readonly pLast: Lazy<ISequenceDeltaRange<TOperation>>;
-
-    constructor(
-        public readonly deltaArgs: IMergeTreeDeltaCallbackArgs<TOperation>,
-        private readonly mergeTreeClient: Client,
-    ) {
-        assert(deltaArgs.deltaSegments.length > 0, 0x2d8 /* "Empty change event should not be emitted." */);
-        this.deltaOperation = deltaArgs.operation;
-
-        this.sortedRanges = new Lazy<SortedSegmentSet<ISequenceDeltaRange<TOperation>>>(
-            () => {
-                const set = new SortedSegmentSet<ISequenceDeltaRange<TOperation>>();
-                this.deltaArgs.deltaSegments.forEach((delta) => {
-                    const newRange: ISequenceDeltaRange<TOperation> = {
-                        operation: this.deltaArgs.operation,
-                        position: this.mergeTreeClient.getPosition(delta.segment),
-                        propertyDeltas: delta.propertyDeltas ?? {},
-                        segment: delta.segment,
-                    };
-                    set.addOrUpdate(newRange);
-                });
-                return set;
-            });
-
-        this.pFirst = new Lazy<ISequenceDeltaRange<TOperation>>(
-            () => this.sortedRanges.value.items[0],
-        );
-
-        this.pLast = new Lazy<ISequenceDeltaRange<TOperation>>(
-            () => this.sortedRanges.value.items[this.sortedRanges.value.size - 1],
-        );
-    }
-
-    /**
-     * The in-order ranges affected by this delta.
-     * These may not be continuous.
-     */
-    public get ranges(): readonly Readonly<ISequenceDeltaRange<TOperation>>[] {
-        return this.sortedRanges.value.items;
-    }
-
-    /**
-     * The client id of the client that made the change which caused the delta event
-     */
-    public get clientId(): string | undefined {
-        return this.mergeTreeClient.longClientId;
-    }
-
-    /**
-     * The first of the modified ranges.
-     */
-    public get first(): Readonly<ISequenceDeltaRange<TOperation>> {
-        return this.pFirst.value;
-    }
-
-    /**
-     * The last of the modified ranges.
-     */
-    public get last(): Readonly<ISequenceDeltaRange<TOperation>> {
-        return this.pLast.value;
-    }
+export abstract class SequenceEvent<
+	TOperation extends MergeTreeDeltaOperationTypes = MergeTreeDeltaOperationTypes,
+> {
+	public readonly deltaOperation: TOperation;
+	private readonly sortedRanges: Lazy<SortedSegmentSet<ISequenceDeltaRange<TOperation>>>;
+	private readonly pFirst: Lazy<ISequenceDeltaRange<TOperation>>;
+	private readonly pLast: Lazy<ISequenceDeltaRange<TOperation>>;
+
+	constructor(
+		public readonly deltaArgs: IMergeTreeDeltaCallbackArgs<TOperation>,
+		private readonly mergeTreeClient: Client,
+	) {
+		assert(
+			deltaArgs.deltaSegments.length > 0,
+			0x2d8 /* "Empty change event should not be emitted." */,
+		);
+		this.deltaOperation = deltaArgs.operation;
+
+		this.sortedRanges = new Lazy<SortedSegmentSet<ISequenceDeltaRange<TOperation>>>(() => {
+			const set = new SortedSegmentSet<ISequenceDeltaRange<TOperation>>();
+			this.deltaArgs.deltaSegments.forEach((delta) => {
+				const newRange: ISequenceDeltaRange<TOperation> = {
+					operation: this.deltaArgs.operation,
+					position: this.mergeTreeClient.getPosition(delta.segment),
+					propertyDeltas: delta.propertyDeltas ?? {},
+					segment: delta.segment,
+				};
+				set.addOrUpdate(newRange);
+			});
+			return set;
+		});
+
+		this.pFirst = new Lazy<ISequenceDeltaRange<TOperation>>(
+			() => this.sortedRanges.value.items[0],
+		);
+
+		this.pLast = new Lazy<ISequenceDeltaRange<TOperation>>(
+			() => this.sortedRanges.value.items[this.sortedRanges.value.size - 1],
+		);
+	}
+
+	/**
+	 * The in-order ranges affected by this delta.
+	 * These may not be continuous.
+	 */
+	public get ranges(): readonly Readonly<ISequenceDeltaRange<TOperation>>[] {
+		return this.sortedRanges.value.items;
+	}
+
+	/**
+	 * The client id of the client that made the change which caused the delta event
+	 */
+	public get clientId(): string | undefined {
+		return this.mergeTreeClient.longClientId;
+	}
+
+	/**
+	 * The first of the modified ranges.
+	 */
+	public get first(): Readonly<ISequenceDeltaRange<TOperation>> {
+		return this.pFirst.value;
+	}
+
+	/**
+	 * The last of the modified ranges.
+	 */
+	public get last(): Readonly<ISequenceDeltaRange<TOperation>> {
+		return this.pLast.value;
+	}
 }
 
 /**
@@ -103,19 +107,19 @@ export abstract class SequenceEvent<TOperation extends MergeTreeDeltaOperationTy
  * Ops may get multiple events. For instance, an insert-replace will get a remove then an insert event.
  */
 export class SequenceDeltaEvent extends SequenceEvent<MergeTreeDeltaOperationType> {
-    /**
-     * Whether the event was caused by a locally-made change.
-     */
-    public readonly isLocal: boolean;
-
-    constructor(
-        public readonly opArgs: IMergeTreeDeltaOpArgs,
-        deltaArgs: IMergeTreeDeltaCallbackArgs,
-        mergeTreeClient: Client,
-    ) {
-        super(deltaArgs, mergeTreeClient);
-        this.isLocal = opArgs.sequencedMessage === undefined;
-    }
+	/**
+	 * Whether the event was caused by a locally-made change.
+	 */
+	public readonly isLocal: boolean;
+
+	constructor(
+		public readonly opArgs: IMergeTreeDeltaOpArgs,
+		deltaArgs: IMergeTreeDeltaCallbackArgs,
+		mergeTreeClient: Client,
+	) {
+		super(deltaArgs, mergeTreeClient);
+		this.isLocal = opArgs.sequencedMessage === undefined;
+	}
 }
 
 /**
@@ -126,61 +130,63 @@ export class SequenceDeltaEvent extends SequenceEvent<MergeTreeDeltaOperationTyp
  * They will not take into consideration any future modifications performed to the underlying sequence and merge tree.
  */
 export class SequenceMaintenanceEvent extends SequenceEvent<MergeTreeMaintenanceType> {
-    constructor(
-        public readonly opArgs: IMergeTreeDeltaOpArgs | undefined,
-        deltaArgs: IMergeTreeMaintenanceCallbackArgs,
-        mergeTreeClient: Client,
-    ) {
-        super(deltaArgs, mergeTreeClient);
-    }
+	constructor(
+		public readonly opArgs: IMergeTreeDeltaOpArgs | undefined,
+		deltaArgs: IMergeTreeMaintenanceCallbackArgs,
+		mergeTreeClient: Client,
+	) {
+		super(deltaArgs, mergeTreeClient);
+	}
 }
 
 /**
  * A range that has changed corresponding to a segment modification.
  */
-export interface ISequenceDeltaRange<TOperation extends MergeTreeDeltaOperationTypes = MergeTreeDeltaOperationTypes> {
-    /**
-     * The type of operation that changed this range.
-     * @remarks - Consuming code should typically compare this to the enum values defined in
-     * `MergeTreeDeltaOperationTypes`.
-     */
-    operation: TOperation;
-    /**
-     * The index of the start of the range.
-     */
-    position: number;
-    /**
-     * The segment that corresponds to the range.
-     */
-    segment: ISegment;
-    /**
-     * Deltas object which contains all modified properties with their previous values.
-     * Since `undefined` doesn't survive a round-trip through JSON serialization, the old value being absent
-     * is instead encoded with `null`.
-     * @remarks - This object is motivated by undo/redo scenarios, and provides a convenient "inverse op" to apply to
-     * undo a property change.
-     * @example - If a segment initially had properties `{ foo: "1", bar: 2 }` and it was annotated with
-     * `{ foo: 3, baz: 5 }`, the corresponding event would have a `propertyDeltas` of `{ foo: "1", baz: null }`.
-     */
-    propertyDeltas: PropertySet;
+export interface ISequenceDeltaRange<
+	TOperation extends MergeTreeDeltaOperationTypes = MergeTreeDeltaOperationTypes,
+> {
+	/**
+	 * The type of operation that changed this range.
+	 * @remarks - Consuming code should typically compare this to the enum values defined in
+	 * `MergeTreeDeltaOperationTypes`.
+	 */
+	operation: TOperation;
+	/**
+	 * The index of the start of the range.
+	 */
+	position: number;
+	/**
+	 * The segment that corresponds to the range.
+	 */
+	segment: ISegment;
+	/**
+	 * Deltas object which contains all modified properties with their previous values.
+	 * Since `undefined` doesn't survive a round-trip through JSON serialization, the old value being absent
+	 * is instead encoded with `null`.
+	 * @remarks - This object is motivated by undo/redo scenarios, and provides a convenient "inverse op" to apply to
+	 * undo a property change.
+	 * @example - If a segment initially had properties `{ foo: "1", bar: 2 }` and it was annotated with
+	 * `{ foo: 3, baz: 5 }`, the corresponding event would have a `propertyDeltas` of `{ foo: "1", baz: null }`.
+	 */
+	propertyDeltas: PropertySet;
 }
 
 class Lazy<T> {
-    private pValue: T | undefined;
-    private pEvaluated: boolean;
-    constructor(private readonly valueGenerator: () => T) {
-        this.pEvaluated = false;
-    }
-
-    public get evaluated(): boolean {
-        return this.pEvaluated;
-    }
-
-    public get value(): T {
-        if (!this.pEvaluated) {
-            this.pEvaluated = true;
-            this.pValue = this.valueGenerator();
-        }
-        return this.pValue as T;
-    }
+	private pValue: T | undefined;
+	private pEvaluated: boolean;
+	constructor(private readonly valueGenerator: () => T) {
+		this.pEvaluated = false;
+	}
+
+	public get evaluated(): boolean {
+		return this.pEvaluated;
+	}
+
+	public get value(): T {
+		if (!this.pEvaluated) {
+			this.pEvaluated = true;
+			this.pValue = this.valueGenerator();
+		}
+		return this.pValue as T;
+	}
 }

package/src/sequenceFactory.ts

@@ -4,63 +4,65 @@
  */
 
 import {
-    IChannelAttributes,
-    IFluidDataStoreRuntime,
-    IChannelServices,
-    IChannelFactory,
+	IChannelAttributes,
+	IFluidDataStoreRuntime,
+	IChannelServices,
+	IChannelFactory,
 } from "@fluidframework/datastore-definitions";
-import {
-    Marker,
-    TextSegment,
-} from "@fluidframework/merge-tree";
+import { Marker, TextSegment } from "@fluidframework/merge-tree";
 import { pkgVersion } from "./packageVersion";
 import { SharedString, SharedStringSegment } from "./sharedString";
 
 export class SharedStringFactory implements IChannelFactory {
-    // TODO rename back to https://graph.microsoft.com/types/mergeTree/string once paparazzi is able to dynamically
-    // load code
-    public static Type = "https://graph.microsoft.com/types/mergeTree";
+	// TODO rename back to https://graph.microsoft.com/types/mergeTree/string once paparazzi is able to dynamically
+	// load code
+	public static Type = "https://graph.microsoft.com/types/mergeTree";
 
-    public static readonly Attributes: IChannelAttributes = {
-        type: SharedStringFactory.Type,
-        snapshotFormatVersion: "0.1",
-        packageVersion: pkgVersion,
-    };
+	public static readonly Attributes: IChannelAttributes = {
+		type: SharedStringFactory.Type,
+		snapshotFormatVersion: "0.1",
+		packageVersion: pkgVersion,
+	};
 
-    public static segmentFromSpec(spec: any): SharedStringSegment {
-        const maybeText = TextSegment.fromJSONObject(spec);
-        if (maybeText) { return maybeText; }
+	public static segmentFromSpec(spec: any): SharedStringSegment {
+		const maybeText = TextSegment.fromJSONObject(spec);
+		if (maybeText) {
+			return maybeText;
+		}
 
-        const maybeMarker = Marker.fromJSONObject(spec);
-        if (maybeMarker) { return maybeMarker; }
+		const maybeMarker = Marker.fromJSONObject(spec);
+		if (maybeMarker) {
+			return maybeMarker;
+		}
 
-        throw new Error(`Unrecognized IJSONObject`);
-    }
+		throw new Error(`Unrecognized IJSONObject`);
+	}
 
-    public get type() {
-        return SharedStringFactory.Type;
-    }
+	public get type() {
+		return SharedStringFactory.Type;
+	}
 
-    public get attributes() {
-        return SharedStringFactory.Attributes;
-    }
+	public get attributes() {
+		return SharedStringFactory.Attributes;
+	}
 
-    /**
-     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}
-     */
-    public async load(
-        runtime: IFluidDataStoreRuntime,
-        id: string,
-        services: IChannelServices,
-        attributes: IChannelAttributes): Promise<SharedString> {
-        const sharedString = new SharedString(runtime, id, attributes);
-        await sharedString.load(services);
-        return sharedString;
-    }
+	/**
+	 * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}
+	 */
+	public async load(
+		runtime: IFluidDataStoreRuntime,
+		id: string,
+		services: IChannelServices,
+		attributes: IChannelAttributes,
+	): Promise<SharedString> {
+		const sharedString = new SharedString(runtime, id, attributes);
+		await sharedString.load(services);
+		return sharedString;
+	}
 
-    public create(document: IFluidDataStoreRuntime, id: string): SharedString {
-        const sharedString = new SharedString(document, id, this.attributes);
-        sharedString.initializeLocal();
-        return sharedString;
-    }
+	public create(document: IFluidDataStoreRuntime, id: string): SharedString {
+		const sharedString = new SharedString(document, id, this.attributes);
+		sharedString.initializeLocal();
+		return sharedString;
+	}
 }