@fluidframework/ordered-collection 2.0.0-internal.3.0.2 → 2.0.0-internal.3.2.0

package/src/consensusOrderedCollectionFactory.ts

@@ -4,9 +4,9 @@
  */
 
 import {
-    IChannelAttributes,
-    IFluidDataStoreRuntime,
-    IChannelServices,
+	IChannelAttributes,
+	IFluidDataStoreRuntime,
+	IChannelServices,
 } from "@fluidframework/datastore-definitions";
 import { ConsensusQueue } from "./consensusQueue";
 import { IConsensusOrderedCollection, IConsensusOrderedCollectionFactory } from "./interfaces";
@@ -16,38 +16,39 @@ import { pkgVersion } from "./packageVersion";
  * The factory that defines the consensus queue
  */
 export class ConsensusQueueFactory implements IConsensusOrderedCollectionFactory {
-    public static Type = "https://graph.microsoft.com/types/consensus-queue";
+	public static Type = "https://graph.microsoft.com/types/consensus-queue";
 
-    public static readonly Attributes: IChannelAttributes = {
-        type: ConsensusQueueFactory.Type,
-        snapshotFormatVersion: "0.1",
-        packageVersion: pkgVersion,
-    };
+	public static readonly Attributes: IChannelAttributes = {
+		type: ConsensusQueueFactory.Type,
+		snapshotFormatVersion: "0.1",
+		packageVersion: pkgVersion,
+	};
 
-    public get type() {
-        return ConsensusQueueFactory.Type;
-    }
+	public get type() {
+		return ConsensusQueueFactory.Type;
+	}
 
-    public get attributes() {
-        return ConsensusQueueFactory.Attributes;
-    }
+	public get attributes() {
+		return ConsensusQueueFactory.Attributes;
+	}
 
-    /**
-     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}
-     */
-    public async load(
-        runtime: IFluidDataStoreRuntime,
-        id: string,
-        services: IChannelServices,
-        attributes: IChannelAttributes): Promise<IConsensusOrderedCollection> {
-        const collection = new ConsensusQueue(id, runtime, attributes);
-        await collection.load(services);
-        return collection;
-    }
+	/**
+	 * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}
+	 */
+	public async load(
+		runtime: IFluidDataStoreRuntime,
+		id: string,
+		services: IChannelServices,
+		attributes: IChannelAttributes,
+	): Promise<IConsensusOrderedCollection> {
+		const collection = new ConsensusQueue(id, runtime, attributes);
+		await collection.load(services);
+		return collection;
+	}
 
-    public create(document: IFluidDataStoreRuntime, id: string): IConsensusOrderedCollection {
-        const collection = new ConsensusQueue(id, document, this.attributes);
-        collection.initializeLocal();
-        return collection;
-    }
+	public create(document: IFluidDataStoreRuntime, id: string): IConsensusOrderedCollection {
+		const collection = new ConsensusQueue(id, document, this.attributes);
+		collection.initializeLocal();
+		return collection;
+	}
 }

package/src/consensusQueue.ts

@@ -4,9 +4,9 @@
  */
 
 import {
-    IFluidDataStoreRuntime,
-    IChannelAttributes,
-    IChannelFactory,
+	IFluidDataStoreRuntime,
+	IChannelAttributes,
+	IChannelFactory,
 } from "@fluidframework/datastore-definitions";
 import { ConsensusOrderedCollection } from "./consensusOrderedCollection";
 import { ConsensusQueueFactory } from "./consensusOrderedCollectionFactory";
@@ -17,16 +17,16 @@ import { SnapshotableArray } from "./snapshotableArray";
  * An JS array based queue implementation that is the backing data structure for ConsensusQueue
  */
 class SnapshotableQueue<T> extends SnapshotableArray<T> implements IOrderedCollection<T> {
-    public add(value: T) {
-        this.data.push(value);
-    }
+	public add(value: T) {
+		this.data.push(value);
+	}
 
-    public remove(): T {
-        if (this.size() === 0) {
-            throw new Error("SnapshotableQueue is empty");
-        }
-        return this.data.shift() as T;
-    }
+	public remove(): T {
+		if (this.size() === 0) {
+			throw new Error("SnapshotableQueue is empty");
+		}
+		return this.data.shift() as T;
+	}
 }
 
 /**
@@ -35,31 +35,35 @@ class SnapshotableQueue<T> extends SnapshotableArray<T> implements IOrderedColle
  * An derived type of ConsensusOrderedCollection with a queue as the backing data and order.
  */
 export class ConsensusQueue<T = any> extends ConsensusOrderedCollection<T> {
-    /**
-     * Create a new consensus queue
-     *
-     * @param runtime - data store runtime the new consensus queue belongs to
-     * @param id - optional name of theconsensus queue
-     * @returns newly create consensus queue (but not attached yet)
-     */
-    public static create<T = any>(runtime: IFluidDataStoreRuntime, id?: string) {
-        return runtime.createChannel(id, ConsensusQueueFactory.Type) as ConsensusQueue<T>;
-    }
+	/**
+	 * Create a new consensus queue
+	 *
+	 * @param runtime - data store runtime the new consensus queue belongs to
+	 * @param id - optional name of theconsensus queue
+	 * @returns newly create consensus queue (but not attached yet)
+	 */
+	public static create<T = any>(runtime: IFluidDataStoreRuntime, id?: string) {
+		return runtime.createChannel(id, ConsensusQueueFactory.Type) as ConsensusQueue<T>;
+	}
 
-    /**
-     * Get a factory for ConsensusQueue to register with the data store.
-     *
-     * @returns a factory that creates and load ConsensusQueue
-     */
-    public static getFactory(): IChannelFactory {
-        return new ConsensusQueueFactory();
-    }
+	/**
+	 * Get a factory for ConsensusQueue to register with the data store.
+	 *
+	 * @returns a factory that creates and load ConsensusQueue
+	 */
+	public static getFactory(): IChannelFactory {
+		return new ConsensusQueueFactory();
+	}
 
-    /**
-     * Constructs a new consensus queue. If the object is non-local an id and service interfaces will
-     * be provided
-     */
-    public constructor(id: string, runtime: IFluidDataStoreRuntime, attributes: IChannelAttributes) {
-        super(id, runtime, attributes, new SnapshotableQueue<T>());
-    }
+	/**
+	 * Constructs a new consensus queue. If the object is non-local an id and service interfaces will
+	 * be provided
+	 */
+	public constructor(
+		id: string,
+		runtime: IFluidDataStoreRuntime,
+		attributes: IChannelAttributes,
+	) {
+		super(id, runtime, attributes, new SnapshotableQueue<T>());
+	}
 }

package/src/interfaces.ts

@@ -4,16 +4,16 @@
  */
 
 import {
-    IFluidDataStoreRuntime,
-    IChannelServices,
-    IChannelAttributes,
-    IChannelFactory,
+	IFluidDataStoreRuntime,
+	IChannelServices,
+	IChannelAttributes,
+	IChannelFactory,
 } from "@fluidframework/datastore-definitions";
 import { ISharedObject, ISharedObjectEvents } from "@fluidframework/shared-object-base";
 
 export enum ConsensusResult {
-    Release,
-    Complete,
+	Release,
+	Complete,
 }
 
 /**
@@ -29,45 +29,45 @@ export type ConsensusCallback<T> = (value: T) => Promise<ConsensusResult>;
  * Use for the runtime to create and load distributed data structure by type name of each channel
  */
 export interface IConsensusOrderedCollectionFactory extends IChannelFactory {
-    load(
-        document: IFluidDataStoreRuntime,
-        id: string,
-        services: IChannelServices,
-        attributes: IChannelAttributes): Promise<IConsensusOrderedCollection>;
-
-    create(document: IFluidDataStoreRuntime, id: string): IConsensusOrderedCollection;
+	load(
+		document: IFluidDataStoreRuntime,
+		id: string,
+		services: IChannelServices,
+		attributes: IChannelAttributes,
+	): Promise<IConsensusOrderedCollection>;
+
+	create(document: IFluidDataStoreRuntime, id: string): IConsensusOrderedCollection;
 }
 
 /**
  * Events notifying about addition, acquisition, release and completion of items
  */
 export interface IConsensusOrderedCollectionEvents<T> extends ISharedObjectEvents {
-
-    /**
-     * Event fires when new item is added to the queue or
-     * an item previously acquired is returned back to a queue (including client loosing connection)
-     * @param newlyAdded - indicates if it's newly added item of previously acquired item
-     */
-    (event: "add", listener: (value: T, newlyAdded: boolean) => void): this;
-    /**
-     * Event fires when a client acquired an item
-     * Fires both for locally acquired items, as well as items acquired by remote clients
-     */
-    (event: "acquire", listener: (value: T, clientId?: string) => void): this;
-
-    /**
-     * "Complete event fires when a client completes an item.
-     */
-    (event: "complete", listener: (value: T) => void): this;
-
-    /**
-     * Event fires when locally acquired item is being released back to the queue.
-     * Please note that release process is asynchronous, so it takes a while for it to happen
-     * ("add" event will be fired as result of it)
-     * @param intentional - indicates whether release was intentional (result of returning
-     * ConsensusResult.Release from callback) or it happened as result of lost connection.
-     */
-    (event: "localRelease", listener: (value: T, intentional: boolean) => void): this;
+	/**
+	 * Event fires when new item is added to the queue or
+	 * an item previously acquired is returned back to a queue (including client loosing connection)
+	 * @param newlyAdded - indicates if it's newly added item of previously acquired item
+	 */
+	(event: "add", listener: (value: T, newlyAdded: boolean) => void): this;
+	/**
+	 * Event fires when a client acquired an item
+	 * Fires both for locally acquired items, as well as items acquired by remote clients
+	 */
+	(event: "acquire", listener: (value: T, clientId?: string) => void): this;
+
+	/**
+	 * "Complete event fires when a client completes an item.
+	 */
+	(event: "complete", listener: (value: T) => void): this;
+
+	/**
+	 * Event fires when locally acquired item is being released back to the queue.
+	 * Please note that release process is asynchronous, so it takes a while for it to happen
+	 * ("add" event will be fired as result of it)
+	 * @param intentional - indicates whether release was intentional (result of returning
+	 * ConsensusResult.Release from callback) or it happened as result of lost connection.
+	 */
+	(event: "localRelease", listener: (value: T, intentional: boolean) => void): this;
 }
 
 /**
@@ -94,25 +94,25 @@ export interface IConsensusOrderedCollectionEvents<T> extends ISharedObjectEvent
  * They will not be references to the original input object.  Thus changed to
  * the input object will not reflect the object in the collection.
  */
-export interface IConsensusOrderedCollection<T = any> extends ISharedObject<IConsensusOrderedCollectionEvents<T>> {
-
-    /**
-     * Adds a value to the collection
-     */
-    add(value: T): Promise<void>;
-
-    /**
-     * Retrieves a value from the collection.
-     * @returns Returns true (and calls callback with acquired value) if collection was not empty.
-     * Otherwise returns false.
-     */
-    acquire(callback: ConsensusCallback<T>): Promise<boolean>;
-
-    /**
-     * Wait for a value to be available and remove it from the consensus collection
-     * Calls callback with retrieved value.
-     */
-    waitAndAcquire(callback: ConsensusCallback<T>): Promise<void>;
+export interface IConsensusOrderedCollection<T = any>
+	extends ISharedObject<IConsensusOrderedCollectionEvents<T>> {
+	/**
+	 * Adds a value to the collection
+	 */
+	add(value: T): Promise<void>;
+
+	/**
+	 * Retrieves a value from the collection.
+	 * @returns Returns true (and calls callback with acquired value) if collection was not empty.
+	 * Otherwise returns false.
+	 */
+	acquire(callback: ConsensusCallback<T>): Promise<boolean>;
+
+	/**
+	 * Wait for a value to be available and remove it from the consensus collection
+	 * Calls callback with retrieved value.
+	 */
+	waitAndAcquire(callback: ConsensusCallback<T>): Promise<void>;
 }
 
 /**
@@ -122,9 +122,9 @@ export interface IConsensusOrderedCollection<T = any> extends ISharedObject<ICon
  * TODO: currently input and output is not symmetrical, can they become symmetrical?
  */
 export interface ISnapshotable<T> {
-    asArray(): T[];
+	asArray(): T[];
 
-    loadFrom(values: T[]): void;
+	loadFrom(values: T[]): void;
 }
 
 /**
@@ -135,18 +135,18 @@ export interface ISnapshotable<T> {
  * for the ConsensusOrderedCollection
  */
 export interface IOrderedCollection<T = any> extends ISnapshotable<T> {
-    /**
-     * Adds a value to the collection
-     */
-    add(value: T);
-
-    /**
-     * Retrieves a value from the collection.
-     */
-    remove(): T;
-
-    /**
-     * Return the size of the collection
-     */
-    size(): number;
+	/**
+	 * Adds a value to the collection
+	 */
+	add(value: T);
+
+	/**
+	 * Retrieves a value from the collection.
+	 */
+	remove(): T;
+
+	/**
+	 * Return the size of the collection
+	 */
+	size(): number;
 }

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/ordered-collection";
-export const pkgVersion = "2.0.0-internal.3.0.2";
+export const pkgVersion = "2.0.0-internal.3.2.0";

package/src/snapshotableArray.ts

@@ -6,18 +6,18 @@
 import { assert } from "@fluidframework/common-utils";
 
 export class SnapshotableArray<T> extends Array {
-    protected data: T[] = [];
+	protected data: T[] = [];
 
-    public asArray() {
-        return this.data;
-    }
+	public asArray() {
+		return this.data;
+	}
 
-    public async loadFrom(from: T[]): Promise<void> {
-        assert(this.data.length === 0, 0x06b /* "Loading snapshot into a non-empty collection" */);
-        this.data = from;
-    }
+	public async loadFrom(from: T[]): Promise<void> {
+		assert(this.data.length === 0, 0x06b /* "Loading snapshot into a non-empty collection" */);
+		this.data = from;
+	}
 
-    public size(): number {
-        return this.data.length;
-    }
+	public size(): number {
+		return this.data.length;
+	}
 }

package/src/testUtils.ts

@@ -3,33 +3,34 @@
  * Licensed under the MIT License.
  */
 
-import {
-    ConsensusResult,
-    IConsensusOrderedCollection,
-} from "./interfaces";
+import { ConsensusResult, IConsensusOrderedCollection } from "./interfaces";
 
 /**
  * Helper method to acquire and complete an item
  * Should be used in test code only
  */
-export async function acquireAndComplete<T>(collection: IConsensusOrderedCollection<T>): Promise<T | undefined> {
-    let res: T | undefined;
-    await collection.acquire(async (value: T) => {
-        res = value;
-        return ConsensusResult.Complete;
-    });
-    return res;
+export async function acquireAndComplete<T>(
+	collection: IConsensusOrderedCollection<T>,
+): Promise<T | undefined> {
+	let res: T | undefined;
+	await collection.acquire(async (value: T) => {
+		res = value;
+		return ConsensusResult.Complete;
+	});
+	return res;
 }
 
 /**
  * Helper method to acquire and complete an item
  * Should be used in test code only
  */
-export async function waitAcquireAndComplete<T>(collection: IConsensusOrderedCollection<T>): Promise<T> {
-    let res: T | undefined;
-    await collection.waitAndAcquire(async (value: T) => {
-        res = value;
-        return ConsensusResult.Complete;
-    });
-    return res as T;
+export async function waitAcquireAndComplete<T>(
+	collection: IConsensusOrderedCollection<T>,
+): Promise<T> {
+	let res: T | undefined;
+	await collection.waitAndAcquire(async (value: T) => {
+		res = value;
+		return ConsensusResult.Complete;
+	});
+	return res as T;
 }

package/tsconfig.esnext.json

@@ -1,7 +1,7 @@
 {
-    "extends": "./tsconfig.json",
-    "compilerOptions": {
-        "outDir": "./lib",
-        "module": "esnext"
-    },
-}
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"outDir": "./lib",
+		"module": "esnext",
+	},
+}

package/tsconfig.json

@@ -1,14 +1,10 @@
 {
-    "extends": "@fluidframework/build-common/ts-common-config.json",
-    "exclude": [
-        "src/test/**/*"
-    ],
-    "compilerOptions": {
-        "rootDir": "./src",
-        "outDir": "./dist",
-        "composite": true
-    },
-    "include": [
-        "src/**/*"
-    ]
-}
+	"extends": "@fluidframework/build-common/ts-common-config.json",
+	"exclude": ["src/test/**/*"],
+	"compilerOptions": {
+		"rootDir": "./src",
+		"outDir": "./dist",
+		"composite": true,
+	},
+	"include": ["src/**/*"],
+}