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

package/src/sharedIntervalCollection.ts

@@ -5,24 +5,24 @@
 
 import { bufferToString } from "@fluidframework/common-utils";
 import {
-    IChannelAttributes,
-    IFluidDataStoreRuntime,
-    IChannelStorageService,
-    IChannelServices,
-    IChannelFactory,
+	IChannelAttributes,
+	IFluidDataStoreRuntime,
+	IChannelStorageService,
+	IChannelServices,
+	IChannelFactory,
 } from "@fluidframework/datastore-definitions";
 import { ISequencedDocumentMessage, MessageType } from "@fluidframework/protocol-definitions";
 import { ISummaryTreeWithStats } from "@fluidframework/runtime-definitions";
 import {
-    createSingleBlobSummary,
-    IFluidSerializer,
-    SharedObject,
+	createSingleBlobSummary,
+	IFluidSerializer,
+	SharedObject,
 } from "@fluidframework/shared-object-base";
 import {
-    Interval,
-    IntervalCollection,
-    IntervalCollectionValueType,
-    ISerializableInterval,
+	Interval,
+	IntervalCollection,
+	IntervalCollectionValueType,
+	ISerializableInterval,
 } from "./intervalCollection";
 import { DefaultMap } from "./defaultMap";
 import { pkgVersion } from "./packageVersion";
@@ -35,137 +35,151 @@ const snapshotFileName = "header";
  * @deprecated `SharedIntervalCollection` is not maintained and is planned to be removed.
  */
 export class SharedIntervalCollectionFactory implements IChannelFactory {
-    public static readonly Type = "https://graph.microsoft.com/types/sharedIntervalCollection";
-
-    public static readonly Attributes: IChannelAttributes = {
-        type: SharedIntervalCollectionFactory.Type,
-        snapshotFormatVersion: "0.1",
-        packageVersion: pkgVersion,
-    };
-
-    public get type() {
-        return SharedIntervalCollectionFactory.Type;
-    }
-
-    public get attributes() {
-        return SharedIntervalCollectionFactory.Attributes;
-    }
-
-    /**
-     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}
-     */
-    public async load(
-        runtime: IFluidDataStoreRuntime,
-        id: string,
-        services: IChannelServices,
-        attributes: IChannelAttributes): Promise<SharedIntervalCollection> {
-        const map = new SharedIntervalCollection(id, runtime, attributes);
-        await map.load(services);
-
-        return map;
-    }
-
-    public create(runtime: IFluidDataStoreRuntime, id: string): SharedIntervalCollection {
-        const map = new SharedIntervalCollection(
-            id,
-            runtime,
-            this.attributes);
-        map.initializeLocal();
-
-        return map;
-    }
+	public static readonly Type = "https://graph.microsoft.com/types/sharedIntervalCollection";
+
+	public static readonly Attributes: IChannelAttributes = {
+		type: SharedIntervalCollectionFactory.Type,
+		snapshotFormatVersion: "0.1",
+		packageVersion: pkgVersion,
+	};
+
+	public get type() {
+		return SharedIntervalCollectionFactory.Type;
+	}
+
+	public get attributes() {
+		return SharedIntervalCollectionFactory.Attributes;
+	}
+
+	/**
+	 * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}
+	 */
+	public async load(
+		runtime: IFluidDataStoreRuntime,
+		id: string,
+		services: IChannelServices,
+		attributes: IChannelAttributes,
+	): Promise<SharedIntervalCollection> {
+		const map = new SharedIntervalCollection(id, runtime, attributes);
+		await map.load(services);
+
+		return map;
+	}
+
+	public create(runtime: IFluidDataStoreRuntime, id: string): SharedIntervalCollection {
+		const map = new SharedIntervalCollection(id, runtime, this.attributes);
+		map.initializeLocal();
+
+		return map;
+	}
 }
 
 export interface ISharedIntervalCollection<TInterval extends ISerializableInterval> {
-    getIntervalCollection(label: string): IntervalCollection<TInterval>;
+	getIntervalCollection(label: string): IntervalCollection<TInterval>;
 }
 
 /**
  * @deprecated `SharedIntervalCollection` is not maintained and is planned to be removed.
  */
 export class SharedIntervalCollection
-    extends SharedObject implements ISharedIntervalCollection<Interval> {
-    /**
-     * Create a SharedIntervalCollection
-     *
-     * @param runtime - data store runtime the new shared map belongs to
-     * @param id - optional name of the shared map
-     * @returns newly create shared map (but not attached yet)
-     */
-    public static create(runtime: IFluidDataStoreRuntime, id?: string) {
-        return runtime.createChannel(id, SharedIntervalCollectionFactory.Type) as SharedIntervalCollection;
-    }
-
-    /**
-     * Get a factory for SharedIntervalCollection to register with the data store.
-     *
-     * @returns a factory that creates and load SharedIntervalCollection
-     */
-    public static getFactory(): IChannelFactory {
-        return new SharedIntervalCollectionFactory();
-    }
-
-    public readonly [Symbol.toStringTag]: string = "SharedIntervalCollection";
-    private readonly intervalCollections: DefaultMap<IntervalCollection<Interval>>;
-
-    /**
-     * Constructs a new shared SharedIntervalCollection. If the object is non-local an id and service interfaces will
-     * be provided
-     */
-    constructor(
-        id: string,
-        runtime: IFluidDataStoreRuntime,
-        attributes: IChannelAttributes,
-    ) {
-        super(id, runtime, attributes, "fluid_sharedIntervalCollection_");
-        this.intervalCollections = new DefaultMap(
-            this.serializer,
-            this.handle,
-            (op, localOpMetadata) => this.submitLocalMessage(op, localOpMetadata),
-            new IntervalCollectionValueType(),
-        );
-    }
-
-    public getIntervalCollection(label: string): IntervalCollection<Interval> {
-        const realLabel = this.getIntervalCollectionPath(label);
-        const sharedCollection = this.intervalCollections.get(realLabel);
-        return sharedCollection;
-    }
-
-    protected summarizeCore(serializer: IFluidSerializer): ISummaryTreeWithStats {
-        return createSingleBlobSummary(snapshotFileName, this.intervalCollections.serialize(serializer));
-    }
-
-    protected reSubmitCore(content: any, localOpMetadata: unknown) {
-        this.intervalCollections.tryResubmitMessage(content, localOpMetadata as IMapMessageLocalMetadata);
-    }
-
-    protected onDisconnect() { }
-
-    /**
-     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
-     */
-    protected async loadCore(storage: IChannelStorageService) {
-        const blob = await storage.readBlob(snapshotFileName);
-        const header = bufferToString(blob, "utf8");
-        this.intervalCollections.populate(header);
-    }
-
-    protected processCore(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown) {
-        if (message.type === MessageType.Operation) {
-            this.intervalCollections.tryProcessMessage(message.contents, local, message, localOpMetadata);
-        }
-    }
-
-    /**
-     * Creates the full path of the intervalCollection label
-     * @param label - the incoming label
-     */
-    protected getIntervalCollectionPath(label: string): string {
-        return label;
-    }
-
-    protected applyStashedOp() {
-        throw new Error("not implemented");
-    }
+	extends SharedObject
+	implements ISharedIntervalCollection<Interval>
+{
+	/**
+	 * Create a SharedIntervalCollection
+	 *
+	 * @param runtime - data store runtime the new shared map belongs to
+	 * @param id - optional name of the shared map
+	 * @returns newly create shared map (but not attached yet)
+	 */
+	public static create(runtime: IFluidDataStoreRuntime, id?: string) {
+		return runtime.createChannel(
+			id,
+			SharedIntervalCollectionFactory.Type,
+		) as SharedIntervalCollection;
+	}
+
+	/**
+	 * Get a factory for SharedIntervalCollection to register with the data store.
+	 *
+	 * @returns a factory that creates and load SharedIntervalCollection
+	 */
+	public static getFactory(): IChannelFactory {
+		return new SharedIntervalCollectionFactory();
+	}
+
+	public readonly [Symbol.toStringTag]: string = "SharedIntervalCollection";
+	private readonly intervalCollections: DefaultMap<IntervalCollection<Interval>>;
+
+	/**
+	 * Constructs a new shared SharedIntervalCollection. If the object is non-local an id and service interfaces will
+	 * be provided
+	 */
+	constructor(id: string, runtime: IFluidDataStoreRuntime, attributes: IChannelAttributes) {
+		super(id, runtime, attributes, "fluid_sharedIntervalCollection_");
+		this.intervalCollections = new DefaultMap(
+			this.serializer,
+			this.handle,
+			(op, localOpMetadata) => this.submitLocalMessage(op, localOpMetadata),
+			new IntervalCollectionValueType(),
+		);
+	}
+
+	public getIntervalCollection(label: string): IntervalCollection<Interval> {
+		const realLabel = this.getIntervalCollectionPath(label);
+		const sharedCollection = this.intervalCollections.get(realLabel);
+		return sharedCollection;
+	}
+
+	protected summarizeCore(serializer: IFluidSerializer): ISummaryTreeWithStats {
+		return createSingleBlobSummary(
+			snapshotFileName,
+			this.intervalCollections.serialize(serializer),
+		);
+	}
+
+	protected reSubmitCore(content: any, localOpMetadata: unknown) {
+		this.intervalCollections.tryResubmitMessage(
+			content,
+			localOpMetadata as IMapMessageLocalMetadata,
+		);
+	}
+
+	protected onDisconnect() {}
+
+	/**
+	 * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
+	 */
+	protected async loadCore(storage: IChannelStorageService) {
+		const blob = await storage.readBlob(snapshotFileName);
+		const header = bufferToString(blob, "utf8");
+		this.intervalCollections.populate(header);
+	}
+
+	protected processCore(
+		message: ISequencedDocumentMessage,
+		local: boolean,
+		localOpMetadata: unknown,
+	) {
+		if (message.type === MessageType.Operation) {
+			this.intervalCollections.tryProcessMessage(
+				message.contents,
+				local,
+				message,
+				localOpMetadata,
+			);
+		}
+	}
+
+	/**
+	 * Creates the full path of the intervalCollection label
+	 * @param label - the incoming label
+	 */
+	protected getIntervalCollectionPath(label: string): string {
+		return label;
+	}
+
+	protected applyStashedOp() {
+		throw new Error("not implemented");
+	}
 }

package/src/sharedSequence.ts

@@ -4,176 +4,181 @@
  */
 
 import { assert } from "@fluidframework/common-utils";
+import { BaseSegment, IJSONSegment, ISegment, PropertySet } from "@fluidframework/merge-tree";
 import {
-    BaseSegment, IJSONSegment, ISegment, PropertySet,
-} from "@fluidframework/merge-tree";
-import { IChannelAttributes, IFluidDataStoreRuntime, Serializable } from "@fluidframework/datastore-definitions";
+	IChannelAttributes,
+	IFluidDataStoreRuntime,
+	Serializable,
+} from "@fluidframework/datastore-definitions";
 import { SharedSegmentSequence } from "./sequence";
 
 const MaxRun = 128;
 
 export interface IJSONRunSegment<T> extends IJSONSegment {
-    items: Serializable<T>[];
+	items: Serializable<T>[];
 }
 
 export class SubSequence<T> extends BaseSegment {
-    public static readonly typeString: string = "SubSequence";
-    public static is(segment: ISegment): segment is SubSequence<any> {
-        return segment.type === SubSequence.typeString;
-    }
-    public static fromJSONObject<U>(spec: Serializable) {
-        if (spec && typeof spec === "object" && "items" in spec) {
-            const segment = new SubSequence<U>(spec.items);
-            if (spec.props) {
-                segment.addProperties(spec.props);
-            }
-            return segment;
-        }
-        return undefined;
-    }
-
-    public readonly type = SubSequence.typeString;
-
-    constructor(public items: Serializable<T>[]) {
-        super();
-        this.cachedLength = items.length;
-    }
-
-    public toJSONObject() {
-        const obj: IJSONRunSegment<T> = { items: this.items };
-        super.addSerializedProps(obj);
-        return obj;
-    }
-
-    public clone(start = 0, end?: number) {
-        const clonedItems = this.items.slice(start, end);
-        const b = new SubSequence(clonedItems);
-        this.cloneInto(b);
-        return b;
-    }
-
-    public canAppend(segment: ISegment): boolean {
-        return SubSequence.is(segment)
-            && (this.cachedLength <= MaxRun || segment.cachedLength <= MaxRun);
-    }
-
-    public toString() {
-        return this.items.toString();
-    }
-
-    public append(segment: ISegment) {
-        assert(SubSequence.is(segment), 0x448 /* can only append to another run segment */);
-        super.append(segment);
-        this.items = this.items.concat(segment.items);
-    }
-
-    // TODO: retain removed items for undo
-    // returns true if entire run removed
-    public removeRange(start: number, end: number) {
-        let remnantItems: Serializable<T>[] = [];
-        const len = this.items.length;
-        if (start > 0) {
-            remnantItems = remnantItems.concat(this.items.slice(0, start));
-        }
-        if (end < len) {
-            remnantItems = remnantItems.concat(this.items.slice(end));
-        }
-        this.items = remnantItems;
-        this.cachedLength = this.items.length;
-        return (this.items.length === 0);
-    }
-
-    protected createSplitSegmentAt(pos: number) {
-        if (pos > 0) {
-            const remainingItems = this.items.slice(pos);
-            this.items = this.items.slice(0, pos);
-            this.cachedLength = this.items.length;
-            const leafSegment = new SubSequence(remainingItems);
-            return leafSegment;
-        }
-    }
+	public static readonly typeString: string = "SubSequence";
+	public static is(segment: ISegment): segment is SubSequence<any> {
+		return segment.type === SubSequence.typeString;
+	}
+	public static fromJSONObject<U>(spec: Serializable) {
+		if (spec && typeof spec === "object" && "items" in spec) {
+			const segment = new SubSequence<U>(spec.items);
+			if (spec.props) {
+				segment.addProperties(spec.props);
+			}
+			return segment;
+		}
+		return undefined;
+	}
+
+	public readonly type = SubSequence.typeString;
+
+	constructor(public items: Serializable<T>[]) {
+		super();
+		this.cachedLength = items.length;
+	}
+
+	public toJSONObject() {
+		const obj: IJSONRunSegment<T> = { items: this.items };
+		super.addSerializedProps(obj);
+		return obj;
+	}
+
+	public clone(start = 0, end?: number) {
+		const clonedItems = this.items.slice(start, end);
+		const b = new SubSequence(clonedItems);
+		this.cloneInto(b);
+		return b;
+	}
+
+	public canAppend(segment: ISegment): boolean {
+		return (
+			SubSequence.is(segment) &&
+			(this.cachedLength <= MaxRun || segment.cachedLength <= MaxRun)
+		);
+	}
+
+	public toString() {
+		return this.items.toString();
+	}
+
+	public append(segment: ISegment) {
+		assert(SubSequence.is(segment), 0x448 /* can only append to another run segment */);
+		super.append(segment);
+		this.items = this.items.concat(segment.items);
+	}
+
+	// TODO: retain removed items for undo
+	// returns true if entire run removed
+	public removeRange(start: number, end: number) {
+		let remnantItems: Serializable<T>[] = [];
+		const len = this.items.length;
+		if (start > 0) {
+			remnantItems = remnantItems.concat(this.items.slice(0, start));
+		}
+		if (end < len) {
+			remnantItems = remnantItems.concat(this.items.slice(end));
+		}
+		this.items = remnantItems;
+		this.cachedLength = this.items.length;
+		return this.items.length === 0;
+	}
+
+	protected createSplitSegmentAt(pos: number) {
+		if (pos > 0) {
+			const remainingItems = this.items.slice(pos);
+			this.items = this.items.slice(0, pos);
+			this.cachedLength = this.items.length;
+			const leafSegment = new SubSequence(remainingItems);
+			return leafSegment;
+		}
+	}
 }
 
 export class SharedSequence<T> extends SharedSegmentSequence<SubSequence<T>> {
-    constructor(
-        document: IFluidDataStoreRuntime,
-        public id: string,
-        attributes: IChannelAttributes,
-        specToSegment: (spec: IJSONSegment) => ISegment,
-    ) {
-        super(document, id, attributes, specToSegment);
-    }
-
-    /**
-     * @param pos - The position to insert the items at.
-     * @param items - The items to insert.
-     * @param props - Optional. Properties to set on the inserted items.
-     */
-    public insert(pos: number, items: Serializable<T>[], props?: PropertySet) {
-        const segment = new SubSequence<T>(items);
-        if (props) {
-            segment.addProperties(props);
-        }
-        const insertOp = this.client.insertSegmentLocal(pos, segment);
-        if (insertOp) {
-            this.submitSequenceMessage(insertOp);
-        }
-    }
-
-    /**
-     * @param start - The inclusive start of the range to remove
-     * @param end - The exclusive end of the range to remove
-     */
-    public remove(start: number, end: number) {
-        this.removeRange(start, end);
-    }
-
-    /**
-     * Returns the total count of items in the sequence
-     */
-    public getItemCount(): number {
-        return this.getLength();
-    }
-
-    /**
-     * Gets the items in the specified range
-     *
-     * @param start - The inclusive start of the range
-     * @param end - The exclusive end of the range
-     */
-    public getItems(start: number, end?: number): Serializable<T>[] {
-        const items: Serializable<T>[] = [];
-        let firstSegment: ISegment | undefined;
-
-        // Return if the range is incorrect.
-        if (end !== undefined && end <= start) {
-            return items;
-        }
-
-        this.walkSegments(
-            (segment: ISegment) => {
-                if (SubSequence.is(segment)) {
-                    if (firstSegment === undefined) {
-                        firstSegment = segment;
-                    }
-                    items.push(...segment.items);
-                }
-                return true;
-            },
-            start,
-            end);
-
-        // The above call to walkSegments adds all the items in the walked
-        // segments. However, we only want items beginning at |start| in
-        // the first segment. Similarly, if |end| is passed in, we only
-        // want items until |end| in the last segment. Remove the rest of
-        // the items.
-        if (firstSegment !== undefined) {
-            items.splice(0, start - this.getPosition(firstSegment));
-        }
-        if (end !== undefined) {
-            items.splice(end - start);
-        }
-        return items;
-    }
+	constructor(
+		document: IFluidDataStoreRuntime,
+		public id: string,
+		attributes: IChannelAttributes,
+		specToSegment: (spec: IJSONSegment) => ISegment,
+	) {
+		super(document, id, attributes, specToSegment);
+	}
+
+	/**
+	 * @param pos - The position to insert the items at.
+	 * @param items - The items to insert.
+	 * @param props - Optional. Properties to set on the inserted items.
+	 */
+	public insert(pos: number, items: Serializable<T>[], props?: PropertySet) {
+		const segment = new SubSequence<T>(items);
+		if (props) {
+			segment.addProperties(props);
+		}
+		const insertOp = this.client.insertSegmentLocal(pos, segment);
+		if (insertOp) {
+			this.submitSequenceMessage(insertOp);
+		}
+	}
+
+	/**
+	 * @param start - The inclusive start of the range to remove
+	 * @param end - The exclusive end of the range to remove
+	 */
+	public remove(start: number, end: number) {
+		this.removeRange(start, end);
+	}
+
+	/**
+	 * Returns the total count of items in the sequence
+	 */
+	public getItemCount(): number {
+		return this.getLength();
+	}
+
+	/**
+	 * Gets the items in the specified range
+	 *
+	 * @param start - The inclusive start of the range
+	 * @param end - The exclusive end of the range
+	 */
+	public getItems(start: number, end?: number): Serializable<T>[] {
+		const items: Serializable<T>[] = [];
+		let firstSegment: ISegment | undefined;
+
+		// Return if the range is incorrect.
+		if (end !== undefined && end <= start) {
+			return items;
+		}
+
+		this.walkSegments(
+			(segment: ISegment) => {
+				if (SubSequence.is(segment)) {
+					if (firstSegment === undefined) {
+						firstSegment = segment;
+					}
+					items.push(...segment.items);
+				}
+				return true;
+			},
+			start,
+			end,
+		);
+
+		// The above call to walkSegments adds all the items in the walked
+		// segments. However, we only want items beginning at |start| in
+		// the first segment. Similarly, if |end| is passed in, we only
+		// want items until |end| in the last segment. Remove the rest of
+		// the items.
+		if (firstSegment !== undefined) {
+			items.splice(0, start - this.getPosition(firstSegment));
+		}
+		if (end !== undefined) {
+			items.splice(end - start);
+		}
+		return items;
+	}
 }