@fluid-experimental/property-common 2.0.0-dev.2.3.0.115467 → 2.0.0-dev.4.1.0.148229

package/src/datastructures/integer64.ts

@@ -26,43 +26,46 @@ const { MSG } = constants;
  * @param high - Higher 32 bit
  */
 export class Integer64 {
-    constructor(protected low = 0, protected high = 0) { }
-
-    /**
-     * @returns The higher 32 bit integer part
-     */
-    getValueHigh() {
-        return this.high;
-    }
-
-    /**
-     * @returns The lower 32 bit integer part
-     */
-    getValueLow() {
-        return this.low;
-    }
-
-    protected _int64toString(isSigned: boolean, in_radix = 10): string {
-        ConsoleUtils.assert(_.isNumber(in_radix), `${MSG.IN_RADIX_MUST_BE_NUMBER} ${in_radix}`);
-        ConsoleUtils.assert(in_radix >= 2 && 36 >= in_radix, `${MSG.BASE_OUT_OF_RANGE} ${in_radix}`);
-
-        let high = this.getValueHigh();
-        let low = this.getValueLow();
-        let result = "";
-        const sign = !!(isSigned && (high & 0x80000000)); // eslint-disable-line no-bitwise
-        if (sign) {
-            high = ~high; // eslint-disable-line no-bitwise
-            low = BIT32 - low;
-        }
-        do {
-            const mod = (high % in_radix) * BIT32 + low;
-            high = Math.floor(high / in_radix);
-            low = Math.floor(mod / in_radix);
-            result = (mod % in_radix).toString(in_radix) + result;
-        } while (high || low);
-
-        return sign ? `-${result}` : result;
-    }
+	constructor(protected low = 0, protected high = 0) {}
+
+	/**
+	 * @returns The higher 32 bit integer part
+	 */
+	getValueHigh() {
+		return this.high;
+	}
+
+	/**
+	 * @returns The lower 32 bit integer part
+	 */
+	getValueLow() {
+		return this.low;
+	}
+
+	protected _int64toString(isSigned: boolean, in_radix = 10): string {
+		ConsoleUtils.assert(_.isNumber(in_radix), `${MSG.IN_RADIX_MUST_BE_NUMBER} ${in_radix}`);
+		ConsoleUtils.assert(
+			in_radix >= 2 && 36 >= in_radix,
+			`${MSG.BASE_OUT_OF_RANGE} ${in_radix}`,
+		);
+
+		let high = this.getValueHigh();
+		let low = this.getValueLow();
+		let result = "";
+		const sign = !!(isSigned && high & 0x80000000); // eslint-disable-line no-bitwise
+		if (sign) {
+			high = ~high; // eslint-disable-line no-bitwise
+			low = BIT32 - low;
+		}
+		do {
+			const mod = (high % in_radix) * BIT32 + low;
+			high = Math.floor(high / in_radix);
+			low = Math.floor(mod / in_radix);
+			result = (mod % in_radix).toString(in_radix) + result;
+		} while (high || low);
+
+		return sign ? `-${result}` : result;
+	}
 }
 
 /**
@@ -81,78 +84,78 @@ export class Integer64 {
  * @returns Low and high bits of `Int64`.
  */
 function _stringToInt64(in_signed: boolean, in_string: string, in_radix = 10): number[] {
-    ConsoleUtils.assert(_.isString(in_string), MSG.IN_STRING_MUST_BE_STRING + in_string);
-    const string = in_string.trim();
-
-    ConsoleUtils.assert(_.isNumber(in_radix), `${MSG.IN_RADIX_BETWEEN_2_36}  ${in_radix}`);
-    ConsoleUtils.assert(in_radix >= 2 && 36 >= in_radix, `${MSG.BASE_OUT_OF_RANGE} ${in_radix}`);
-
-    let position = 0;
-    let negative = false;
-    let high = 0;
-    let low = 0;
-    if (string[0] === "-") {
-        negative = true;
-        position += 1;
-    }
-
-    ConsoleUtils.assert(!negative || in_signed, MSG.CANNOT_UPDATE_TO_NEGATIVE + string);
-
-    while (position < string.length) {
-        const digit = parseInt(string[position++], in_radix);
-        if (isNaN(digit)) {
-            throw new TypeError(MSG.CANNOT_PARSE_INVALID_CHARACTERS + string);
-        }
-        low = low * in_radix + digit;
-        high = high * in_radix + Math.floor(low / BIT32);
-        low %= BIT32;
-    }
-
-    if (negative) {
-        // eslint-disable-next-line no-bitwise
-        high = ~high;
-        if (low) {
-            low = BIT32 - low;
-        } else {
-            high += 1;
-        }
-    }
-
-    return [low, high];
+	ConsoleUtils.assert(_.isString(in_string), MSG.IN_STRING_MUST_BE_STRING + in_string);
+	const string = in_string.trim();
+
+	ConsoleUtils.assert(_.isNumber(in_radix), `${MSG.IN_RADIX_BETWEEN_2_36}  ${in_radix}`);
+	ConsoleUtils.assert(in_radix >= 2 && 36 >= in_radix, `${MSG.BASE_OUT_OF_RANGE} ${in_radix}`);
+
+	let position = 0;
+	let negative = false;
+	let high = 0;
+	let low = 0;
+	if (string[0] === "-") {
+		negative = true;
+		position += 1;
+	}
+
+	ConsoleUtils.assert(!negative || in_signed, MSG.CANNOT_UPDATE_TO_NEGATIVE + string);
+
+	while (position < string.length) {
+		const digit = parseInt(string[position++], in_radix);
+		if (isNaN(digit)) {
+			throw new TypeError(MSG.CANNOT_PARSE_INVALID_CHARACTERS + string);
+		}
+		low = low * in_radix + digit;
+		high = high * in_radix + Math.floor(low / BIT32);
+		low %= BIT32;
+	}
+
+	if (negative) {
+		// eslint-disable-next-line no-bitwise
+		high = ~high;
+		if (low) {
+			low = BIT32 - low;
+		} else {
+			high += 1;
+		}
+	}
+
+	return [low, high];
 }
 
 /**
  * A data representation class for the signed 64 bit integer type
  */
 export class Int64 extends Integer64 {
-    static fromString = function(in_string: string, radix = 10) {
-        const [low, high] = _stringToInt64(true, in_string, radix);
-        return new Int64(low, high);
-    };
-
-    clone() {
-        return new Int64(this.low, this.high);
-    }
-
-    toString(radix = 10) {
-        return this._int64toString(true, radix);
-    }
+	static fromString = function (in_string: string, radix = 10) {
+		const [low, high] = _stringToInt64(true, in_string, radix);
+		return new Int64(low, high);
+	};
+
+	clone() {
+		return new Int64(this.low, this.high);
+	}
+
+	toString(radix = 10) {
+		return this._int64toString(true, radix);
+	}
 }
 
 /**
  * A data representation class for the unsigned 64 bit integer type
  */
 export class Uint64 extends Integer64 {
-    static fromString(in_string: string, in_radix = 10) {
-        const [low, high] = _stringToInt64.call(this, false, in_string, in_radix);
-        return new Uint64(low, high);
-    }
-
-    clone() {
-        return new Uint64(this.low, this.high);
-    }
-
-    toString(radix) {
-        return this._int64toString(false, radix);
-    }
+	static fromString(in_string: string, in_radix = 10) {
+		const [low, high] = _stringToInt64.call(this, false, in_string, in_radix);
+		return new Uint64(low, high);
+	}
+
+	clone() {
+		return new Uint64(this.low, this.high);
+	}
+
+	toString(radix) {
+		return this._int64toString(false, radix);
+	}
 }

package/src/datastructures/sortedCollection.ts

@@ -12,149 +12,159 @@ import _ from "lodash";
 import { Collection } from "./collection";
 
 export class SortedCollection<T> extends Collection<T> {
-    private _sortedKeys: string[] = [];
-    private _comparisonFunction?: (x: string, y: string) => number = undefined;
-
-    /**
-     * A sorted collection class.
-     * @param in_name - a friendly name to describe this collection. If undefined
-     * the collection will have a default "Untitled Collection" assigned to its name.
-     * @param in_type - optional parameter pointing to the constructor
-     * of a type this Collection will host.
-     */
-    constructor(in_name?: string, in_type?) {
-        super(in_name, in_type);
-    }
-
-    /**
-     * Set the comparison function. By default the keys will be sorted wrt their ASCII code.
-     *
-     * @param in_fn - The function to compare two entries.
-     * The return value of this function must convey to the following cases:
-     *
-     * - if a \> b, then the return value must be greater than 0.
-     *
-     * - if a \< b, then the return value must be less than 0.
-     *
-     * - if a == b, then the return value must be 0.
-     */
-    setComparisonFunction(in_fn?: (x: string, y: string) => number) {
-        console.assert(_.isFunction(in_fn), "Must provide a function");
-        this._comparisonFunction = in_fn;
-    }
-
-    /**
-     * Add an item to the collection. Sort the list of keys in an ascending order.
-     *
-     * @param in_key - Key to store the value under.
-     * @param in_value - Value to store in the collection.
-     *
-     * @returns The value passed in.
-     */
-    add(in_key: string | number, in_value: T) {
-        const toReturn = super.add(in_key, in_value);
-
-        this._sortedKeys.push(in_key.toString());
-        this._sortedKeys.sort(this._comparisonFunction);
-
-        return toReturn;
-    }
-
-    /**
-     * Remove an item from this Collection. This method returns a Boolean indicating
-     * the success or failure of the removal. This is practical because if we were
-     * to throw an error when the key doesn't exist, it would require additional
-     * checks by the caller to make sure this key exists prior to removal. Which
-     * would make the attempt of removal more verbose and also costly because the
-     * caller would have to keep a list – somewhere else – of the things he can
-     * and cannot remove.
-     *
-     * @param in_key - the key we wish to remove
-     * @returns true if the key exists and was removed, false otherwise.
-     */
-    remove(in_key: string) {
-        const toReturn = super.remove(in_key);
-        this._sortedKeys = _.without(this._sortedKeys, in_key);
-        return toReturn;
-    }
-
-    /**
-     * Copy the items of in_collection to this collection.
-     * @returns cloned SortedCollection
-     */
-    clone(): SortedCollection<T> {
-        const newCol = new SortedCollection<T>(this._name, this._type);
-        newCol.setComparisonFunction(this._comparisonFunction);
-        newCol.bulkAdd(this._items);
-        return newCol;
-    }
-
-    /**
-     * Internal function use to search (binary search) for the nearest index that
-     * the given key would be inserted.
-     * i.e. given the array [10, 20, 30, 40, 50] the index that 35 should be inserted at is 3
-     * @param in_array - Target array
-     * @param in_key - Key to check against
-     * @returns The index at which the key would be inserted in
-     */
-    private _binarySearchNearestIndex(in_array: string[], in_key: string): number {
-        if (this._comparisonFunction === undefined) {
-            return _.sortedIndex(in_array, in_key);
-        } else {
-            const middleIndex = Math.floor((in_array.length - 1) / 2);
-
-            if (middleIndex < 0) {
-                return 0;
-            }
-
-            if (this._comparisonFunction(in_array[middleIndex], in_key) > 0) {
-                if (in_array.length === 1) {
-                    return 0;
-                }
-
-                return this._binarySearchNearestIndex(in_array.slice(0, middleIndex), in_key);
-            }
-
-            if (this._comparisonFunction(in_array[middleIndex], in_key) < 0) {
-                if (in_array.length === 1) {
-                    return 1;
-                }
-
-                return (middleIndex + 1) + this._binarySearchNearestIndex(
-                    in_array.slice(middleIndex + 1, in_array.length),
-                    in_key,
-                );
-            }
-
-            return middleIndex;
-        }
-    }
-
-    /**
-     * Return the nearest next item to the given key i.e.
-     * For the given list of keys ['1.0.1', '2.0.0', '2.2.0', '7.0.1'] the nearest next item to 6.0.1 is
-     * the item mapped by '7.0.1'
-     * @param in_key - The key to check against in order to get the nearest next item
-     * @returns The nearest next item
-     */
-    getNearestNextItem(in_key: string) {
-        const closestNextIndex = this._binarySearchNearestIndex(this._sortedKeys, in_key.toString());
-        return closestNextIndex === this.getCount()
-            ? undefined
-            : this.item(this._sortedKeys[closestNextIndex]);
-    }
-
-    /**
-     * Return the nearest previous item to the given key i.e.
-     * For the given list of keys ['1.0.1', '2.0.0', '2.2.0', '7.0.1'] the nearest previous item to 6.0.1 is
-     * the item mapped by '7.0.1'
-     * @param in_key - The key to check against in order to get the nearest previous item
-     * @returns The nearest previous item
-     */
-    getNearestPreviousItem(in_key: string | number) {
-        const closestPreviousIndex = this._binarySearchNearestIndex(this._sortedKeys, in_key.toString());
-        return closestPreviousIndex === 0
-            ? undefined
-            : this.item(this._sortedKeys[closestPreviousIndex - 1]);
-    }
+	private _sortedKeys: string[] = [];
+	private _comparisonFunction?: (x: string, y: string) => number = undefined;
+
+	/**
+	 * A sorted collection class.
+	 * @param in_name - a friendly name to describe this collection. If undefined
+	 * the collection will have a default "Untitled Collection" assigned to its name.
+	 * @param in_type - optional parameter pointing to the constructor
+	 * of a type this Collection will host.
+	 */
+	constructor(in_name?: string, in_type?) {
+		super(in_name, in_type);
+	}
+
+	/**
+	 * Set the comparison function. By default the keys will be sorted wrt their ASCII code.
+	 *
+	 * @param in_fn - The function to compare two entries.
+	 * The return value of this function must convey to the following cases:
+	 *
+	 * - if a \> b, then the return value must be greater than 0.
+	 *
+	 * - if a \< b, then the return value must be less than 0.
+	 *
+	 * - if a == b, then the return value must be 0.
+	 */
+	setComparisonFunction(in_fn?: (x: string, y: string) => number) {
+		console.assert(_.isFunction(in_fn), "Must provide a function");
+		this._comparisonFunction = in_fn;
+	}
+
+	/**
+	 * Add an item to the collection. Sort the list of keys in an ascending order.
+	 *
+	 * @param in_key - Key to store the value under.
+	 * @param in_value - Value to store in the collection.
+	 *
+	 * @returns The value passed in.
+	 */
+	add(in_key: string | number, in_value: T) {
+		const toReturn = super.add(in_key, in_value);
+
+		this._sortedKeys.push(in_key.toString());
+		this._sortedKeys.sort(this._comparisonFunction);
+
+		return toReturn;
+	}
+
+	/**
+	 * Remove an item from this Collection. This method returns a Boolean indicating
+	 * the success or failure of the removal. This is practical because if we were
+	 * to throw an error when the key doesn't exist, it would require additional
+	 * checks by the caller to make sure this key exists prior to removal. Which
+	 * would make the attempt of removal more verbose and also costly because the
+	 * caller would have to keep a list – somewhere else – of the things he can
+	 * and cannot remove.
+	 *
+	 * @param in_key - the key we wish to remove
+	 * @returns true if the key exists and was removed, false otherwise.
+	 */
+	remove(in_key: string) {
+		const toReturn = super.remove(in_key);
+		this._sortedKeys = _.without(this._sortedKeys, in_key);
+		return toReturn;
+	}
+
+	/**
+	 * Copy the items of in_collection to this collection.
+	 * @returns cloned SortedCollection
+	 */
+	clone(): SortedCollection<T> {
+		const newCol = new SortedCollection<T>(this._name, this._type);
+		newCol.setComparisonFunction(this._comparisonFunction);
+		newCol.bulkAdd(this._items);
+		return newCol;
+	}
+
+	/**
+	 * Internal function use to search (binary search) for the nearest index that
+	 * the given key would be inserted.
+	 * i.e. given the array [10, 20, 30, 40, 50] the index that 35 should be inserted at is 3
+	 * @param in_array - Target array
+	 * @param in_key - Key to check against
+	 * @returns The index at which the key would be inserted in
+	 */
+	private _binarySearchNearestIndex(in_array: string[], in_key: string): number {
+		if (this._comparisonFunction === undefined) {
+			return _.sortedIndex(in_array, in_key);
+		} else {
+			const middleIndex = Math.floor((in_array.length - 1) / 2);
+
+			if (middleIndex < 0) {
+				return 0;
+			}
+
+			if (this._comparisonFunction(in_array[middleIndex], in_key) > 0) {
+				if (in_array.length === 1) {
+					return 0;
+				}
+
+				return this._binarySearchNearestIndex(in_array.slice(0, middleIndex), in_key);
+			}
+
+			if (this._comparisonFunction(in_array[middleIndex], in_key) < 0) {
+				if (in_array.length === 1) {
+					return 1;
+				}
+
+				return (
+					middleIndex +
+					1 +
+					this._binarySearchNearestIndex(
+						in_array.slice(middleIndex + 1, in_array.length),
+						in_key,
+					)
+				);
+			}
+
+			return middleIndex;
+		}
+	}
+
+	/**
+	 * Return the nearest next item to the given key i.e.
+	 * For the given list of keys ['1.0.1', '2.0.0', '2.2.0', '7.0.1'] the nearest next item to 6.0.1 is
+	 * the item mapped by '7.0.1'
+	 * @param in_key - The key to check against in order to get the nearest next item
+	 * @returns The nearest next item
+	 */
+	getNearestNextItem(in_key: string) {
+		const closestNextIndex = this._binarySearchNearestIndex(
+			this._sortedKeys,
+			in_key.toString(),
+		);
+		return closestNextIndex === this.getCount()
+			? undefined
+			: this.item(this._sortedKeys[closestNextIndex]);
+	}
+
+	/**
+	 * Return the nearest previous item to the given key i.e.
+	 * For the given list of keys ['1.0.1', '2.0.0', '2.2.0', '7.0.1'] the nearest previous item to 6.0.1 is
+	 * the item mapped by '7.0.1'
+	 * @param in_key - The key to check against in order to get the nearest previous item
+	 * @returns The nearest previous item
+	 */
+	getNearestPreviousItem(in_key: string | number) {
+		const closestPreviousIndex = this._binarySearchNearestIndex(
+			this._sortedKeys,
+			in_key.toString(),
+		);
+		return closestPreviousIndex === 0
+			? undefined
+			: this.item(this._sortedKeys[closestPreviousIndex - 1]);
+	}
 }

package/src/deferredPromise.ts

@@ -10,52 +10,53 @@
  * tasks to terminate. This class becomes useful when combining classic async calls with promises.
  */
 export class DeferredPromise<T> implements Promise<T> {
-    private _resolveSelf;
-    private _rejectSelf;
-    private readonly promise: Promise<T>;
+	private _resolveSelf;
+	private _rejectSelf;
+	private readonly promise: Promise<T>;
 
-    constructor() {
-        this.promise = new Promise((resolve, reject) => {
-            this._resolveSelf = resolve;
-            this._rejectSelf = reject;
-        });
-    }
-    [Symbol.toStringTag]: string;
+	constructor() {
+		this.promise = new Promise((resolve, reject) => {
+			this._resolveSelf = resolve;
+			this._rejectSelf = reject;
+		});
+	}
+	readonly [Symbol.toStringTag]: string = "DeferredPromise";
 
-    public async finally(onfinally?: () => void): Promise<T> {
-        throw new Error("Method not implemented.");
-    }
+	public async finally(onfinally?: () => void): Promise<T> {
+		throw new Error("Method not implemented.");
+	}
 
-    /**
-     * Fetches a node style callback that fulfills the promise when called.
-     * @returns A node style callback that fulfills the promise when called.
-     */
-    getCb() {
-        return (error, result) => {
-            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-            if (error) {
-                return this.reject(error);
-            }
-            return this.resolve(result);
-        };
-    }
+	/**
+	 * Fetches a node style callback that fulfills the promise when called.
+	 * @returns A node style callback that fulfills the promise when called.
+	 */
+	getCb() {
+		return (error, result) => {
+			// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+			if (error) {
+				return this.reject(error);
+			}
+			return this.resolve(result);
+		};
+	}
 
-    public async then<TResult1 = T, TResult2 = never>(
-        onfulfilled?: ((value: T) =>
-            TResult1 | PromiseLike<TResult1>) | undefined | null,
-        onrejected?: ((reason: any) =>
-            TResult2 | PromiseLike<TResult2>) | undefined | null,
-    ): Promise<TResult1 | TResult2> {
-        return this.promise.then(onfulfilled, onrejected);
-    }
+	public async then<TResult1 = T, TResult2 = never>(
+		onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null,
+		onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null,
+	): Promise<TResult1 | TResult2> {
+		return this.promise.then(onfulfilled, onrejected);
+	}
 
-    public async catch<TResult = never>(
-        onrejected?: ((reason: any) =>
-            TResult | PromiseLike<TResult>) | undefined | null,
-    ): Promise<T | TResult> {
-        return this.promise.then(onrejected);
-    }
+	public async catch<TResult = never>(
+		onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null,
+	): Promise<T | TResult> {
+		return this.promise.then(onrejected);
+	}
 
-    public resolve(val: T) { this._resolveSelf(val); }
-    public reject(reason: any) { this._rejectSelf(reason); }
+	public resolve(val: T) {
+		this._resolveSelf(val);
+	}
+	public reject(reason: any) {
+		this._rejectSelf(reason);
+	}
 }