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

package/src/deterministicRandomGenerator.ts

@@ -21,69 +21,69 @@ import { calculateHash } from "./hashCalculator";
  * efficient.
  */
 export class DeterministicRandomGenerator {
-    _guid1: Uint32Array;
-    _guid2: Uint32Array;
-    _result: Uint32Array;
+	_guid1: Uint32Array;
+	_guid2: Uint32Array;
+	_result: Uint32Array;
 
-    /**
-     * @param in_seed - The initial seed (it can be either a GUID or a number)
-     * which is used to initialize the random number generator.
-     */
-    constructor(in_seed: string | number) {
-        // Initialize the internal state from the given initial guid
-        this._guid1 = _.isString(in_seed)
-            ? GuidUtils.guidToUint32x4(in_seed)
-            : GuidUtils.guidToUint32x4(calculateHash(String(in_seed)));
-        this._guid2 = new Uint32Array(4);
-        this._guid2[0] = (this._guid1[0] + 1) >>> 0;
-        this._guid2[1] = (this._guid1[1] + 1) >>> 0;
-        this._guid2[2] = (this._guid1[2] + 1) >>> 0;
-        this._guid2[3] = (this._guid1[3] + 1) >>> 0;
+	/**
+	 * @param in_seed - The initial seed (it can be either a GUID or a number)
+	 * which is used to initialize the random number generator.
+	 */
+	constructor(in_seed: string | number) {
+		// Initialize the internal state from the given initial guid
+		this._guid1 = _.isString(in_seed)
+			? GuidUtils.guidToUint32x4(in_seed)
+			: GuidUtils.guidToUint32x4(calculateHash(String(in_seed)));
+		this._guid2 = new Uint32Array(4);
+		this._guid2[0] = (this._guid1[0] + 1) >>> 0;
+		this._guid2[1] = (this._guid1[1] + 1) >>> 0;
+		this._guid2[2] = (this._guid1[2] + 1) >>> 0;
+		this._guid2[3] = (this._guid1[3] + 1) >>> 0;
 
-        this._result = new Uint32Array(4);
-    }
+		this._result = new Uint32Array(4);
+	}
 
-    /**
-     * Creates a floating point random number.
-     *
-     * @param in_max - If supplied the returned number will be 0 \<= number \< `in_max`.
-     * If none is given, `in_max` = 1 is assumed.
-     *
-     * @returns The random number.
-     */
-    random(in_max = 1.0) {
-        const randomInteger = this.irandom();
-        return randomInteger / 4294967296 * in_max;
-    }
+	/**
+	 * Creates a floating point random number.
+	 *
+	 * @param in_max - If supplied the returned number will be 0 \<= number \< `in_max`.
+	 * If none is given, `in_max` = 1 is assumed.
+	 *
+	 * @returns The random number.
+	 */
+	random(in_max = 1.0) {
+		const randomInteger = this.irandom();
+		return (randomInteger / 4294967296) * in_max;
+	}
 
-    /**
-     * Creates an integer point random number.
-     *
-     * @param in_max - If supplied the returned number will be 0 \<= number \< `in_max`.
-     * If none is given, `in_max` = 14294967296 (2^32) is assumed.
-     *
-     * @returns The random number.
-     */
-    irandom(in_max?: number): number {
-        // Create a new hash
-        GuidUtils.hashCombine4xUint32(this._guid1, this._guid2, this._result);
+	/**
+	 * Creates an integer point random number.
+	 *
+	 * @param in_max - If supplied the returned number will be 0 \<= number \< `in_max`.
+	 * If none is given, `in_max` = 14294967296 (2^32) is assumed.
+	 *
+	 * @returns The random number.
+	 */
+	irandom(in_max?: number): number {
+		// Create a new hash
+		GuidUtils.hashCombine4xUint32(this._guid1, this._guid2, this._result);
 
-        // Permute the hashes
-        for (let i = 0; i < 4; i++) {
-            this._guid1[i] = this._guid2[i];
-            this._guid2[i] = this._result[i];
-        }
+		// Permute the hashes
+		for (let i = 0; i < 4; i++) {
+			this._guid1[i] = this._guid2[i];
+			this._guid2[i] = this._result[i];
+		}
 
-        if (in_max === undefined) {
-            return this._guid1[0];
-        } else {
-            return in_max < 16777619
-                // The random generator doesn't seem to be very good.
-                // It is quite biased (e.g. it generates too many even numbers)
-                // this is a hack to solve at least this problem, but we probably should
-                // instead use a different approach altogether
-                ? ((this._guid1[0]) % 16777619) % in_max
-                : this._guid1[0] % in_max;
-        }
-    }
+		if (in_max === undefined) {
+			return this._guid1[0];
+		} else {
+			return in_max < 16777619
+				? // The random generator doesn't seem to be very good.
+				  // It is quite biased (e.g. it generates too many even numbers)
+				  // this is a hack to solve at least this problem, but we probably should
+				  // instead use a different approach altogether
+				  (this._guid1[0] % 16777619) % in_max
+				: this._guid1[0] % in_max;
+		}
+	}
 }

package/src/error_objects/flaggedError.ts

@@ -9,39 +9,39 @@
  * @param flag - A flag to be checked
  * @returns True if the flag is set in passed flags, false otherwise.
  */
- const _isFlagSet = (flags: number, flag: number) => {
-    // eslint-disable-next-line no-bitwise
-    return (flags & flag) === flag;
+const _isFlagSet = (flags: number, flag: number) => {
+	// eslint-disable-next-line no-bitwise
+	return (flags & flag) === flag;
 };
 
 export class FlaggedError {
-    /**
-     * Flags that may be set on an error instance.
-     */
-    static FLAGS = {
-        /**
-         * A transient error results from an operation that could succeed if retried.
-         */
-        TRANSIENT: 1,
-        /**
-         * A quiet error should not trigger an error log.
-         */
-        QUIET: 2,
-    };
+	/**
+	 * Flags that may be set on an error instance.
+	 */
+	static FLAGS = {
+		/**
+		 * A transient error results from an operation that could succeed if retried.
+		 */
+		TRANSIENT: 1,
+		/**
+		 * A quiet error should not trigger an error log.
+		 */
+		QUIET: 2,
+	};
 
-    protected flags: number = 0;
+	protected flags: number = 0;
 
-    /**
-     * @returns True if the quiet flag is set.
-     */
-    isQuiet(): boolean {
-        return _isFlagSet(this.flags, FlaggedError.FLAGS.QUIET);
-    }
+	/**
+	 * @returns True if the quiet flag is set.
+	 */
+	isQuiet(): boolean {
+		return _isFlagSet(this.flags, FlaggedError.FLAGS.QUIET);
+	}
 
-    /**
-     * @returns True if the transient flag is set.
-     */
-    isTransient(): boolean {
-        return _isFlagSet(this.flags, FlaggedError.FLAGS.TRANSIENT);
-    }
+	/**
+	 * @returns True if the transient flag is set.
+	 */
+	isTransient(): boolean {
+		return _isFlagSet(this.flags, FlaggedError.FLAGS.TRANSIENT);
+	}
 }

package/src/error_objects/httpError.ts

@@ -14,54 +14,57 @@ import { FlaggedError } from "./flaggedError";
  * @param flags - Flags that characterize the error. See {@link FlaggedError.FLAGS}.
  */
 export class HTTPError extends Error {
-    constructor(
-        public title?: string,
-        public statusCode?: number,
-        public statusMessage?: string,
-        public method?: string,
-        public url?: string,
-        public flags = 0,
-    ) {
-        super();
-        Object.setPrototypeOf(this, HTTPError.prototype);
-        this.name = "HTTPError";
-        this.message = this._generateMessage(title, statusCode, statusMessage, method, url);
-        this.stack = (new Error(this.message)).stack;
-    }
+	constructor(
+		public title?: string,
+		public statusCode?: number,
+		public statusMessage?: string,
+		public method?: string,
+		public url?: string,
+		public flags = 0,
+	) {
+		super();
+		Object.setPrototypeOf(this, HTTPError.prototype);
+		this.name = "HTTPError";
+		this.message = this._generateMessage(title, statusCode, statusMessage, method, url);
+		this.stack = new Error(this.message).stack;
+	}
 
-    static FLAGS = FlaggedError.FLAGS;
+	static FLAGS = FlaggedError.FLAGS;
 
-    isQuiet(): boolean {
-        return FlaggedError.prototype.isQuiet.call(this);
-    }
+	isQuiet(): boolean {
+		return FlaggedError.prototype.isQuiet.call(this);
+	}
 
-    isTransient(): boolean {
-        return FlaggedError.prototype.isTransient.call(this);
-    }
+	isTransient(): boolean {
+		return FlaggedError.prototype.isTransient.call(this);
+	}
 
-    private _generateMessage(title, statusCode, statusMessage, method, url) {
-        const titleStr = (title === undefined) ? "" : String(title);
-        const statusCodeStr = (statusCode === undefined) ? "" : String(statusCode);
-        const statusMessageStr = (statusMessage === undefined) ? "" : String(statusMessage);
-        const methodStr = (method === undefined) ? "" : String(method);
-        const urlStr = (url === undefined) ? "" : String(url);
+	private _generateMessage(title, statusCode, statusMessage, method, url) {
+		const titleStr = title === undefined ? "" : String(title);
+		const statusCodeStr = statusCode === undefined ? "" : String(statusCode);
+		const statusMessageStr = statusMessage === undefined ? "" : String(statusMessage);
+		const methodStr = method === undefined ? "" : String(method);
+		const urlStr = url === undefined ? "" : String(url);
 
-        return `HTTPError: ${titleStr}, statusCode:${statusCodeStr}, ` +
-            `statusMessage:${statusMessageStr}, method:${methodStr}, url:${urlStr}`;
-    }
+		return (
+			`HTTPError: ${titleStr}, statusCode:${statusCodeStr}, ` +
+			`statusMessage:${statusMessageStr}, method:${methodStr}, url:${urlStr}`
+		);
+	}
 
-    /**
-     * Returns a string representing the HTTPError object
-     * @returns a string representing the HTTPError object
-     */
-    toString(): string {
-        const stack = (this.stack === undefined) ? "" : String(this.stack);
+	/**
+	 * Returns a string representing the HTTPError object
+	 * @returns a string representing the HTTPError object
+	 */
+	toString(): string {
+		const stack = this.stack === undefined ? "" : String(this.stack);
 
-        const isFirefox = typeof window !== "undefined" &&
-            typeof window.navigator !== "undefined" &&
-            typeof window.navigator.userAgent !== "undefined" &&
-            window.navigator.userAgent.toLowerCase().includes("firefox");
+		const isFirefox =
+			typeof window !== "undefined" &&
+			typeof window.navigator !== "undefined" &&
+			typeof window.navigator.userAgent !== "undefined" &&
+			window.navigator.userAgent.toLowerCase().includes("firefox");
 
-        return isFirefox ? `${this.message}, stack:${stack}` : `stack:${stack}`;
-    }
+		return isFirefox ? `${this.message}, stack:${stack}` : `stack:${stack}`;
+	}
 }

package/src/error_objects/httpErrorNoStack.ts

@@ -9,23 +9,23 @@ import { FlaggedError } from "./flaggedError";
  * Class extending HTTPError without storing the stack
  */
 export class HTTPErrorNoStack extends HTTPError {
-    static FLAGS = FlaggedError.FLAGS;
+	static FLAGS = FlaggedError.FLAGS;
 
-    /**
-     * @param message - The error message
-     * @param statusCode - A numeric HTTP status code
-     * @param statusMessage - A string message representing the response status message
-     * @param method - The HTTP method used in the request
-     * @param url - The URL that the request was sent to
-     * @param flags - Flags that characterize the error. See {@link FlaggedError.FLAGS}.
-     */
-    constructor(message?, statusCode?, statusMessage?, method?, url?, flags?) {
-        super(message, statusCode, statusMessage, method, url, flags);
-        Object.setPrototypeOf(this, HTTPErrorNoStack.prototype);
-        delete this.stack;
-    }
+	/**
+	 * @param message - The error message
+	 * @param statusCode - A numeric HTTP status code
+	 * @param statusMessage - A string message representing the response status message
+	 * @param method - The HTTP method used in the request
+	 * @param url - The URL that the request was sent to
+	 * @param flags - Flags that characterize the error. See {@link FlaggedError.FLAGS}.
+	 */
+	constructor(message?, statusCode?, statusMessage?, method?, url?, flags?) {
+		super(message, statusCode, statusMessage, method, url, flags);
+		Object.setPrototypeOf(this, HTTPErrorNoStack.prototype);
+		delete this.stack;
+	}
 
-    toString(): string {
-        return this.message;
-    }
+	toString(): string {
+		return this.message;
+	}
 }

package/src/error_objects/operationError.ts

@@ -13,78 +13,78 @@ import _ from "lodash";
 import { FlaggedError } from "./flaggedError";
 
 export class OperationError extends Error {
-    static FLAGS = FlaggedError.FLAGS;
-    public stack: string | undefined;
-    public readonly name: string;
+	static FLAGS = FlaggedError.FLAGS;
+	public stack: string | undefined;
+	public readonly name: string;
 
-    /**
-       * Instantiates an OperationError, which mimics the Error class with added properties
-       * meant for reporting the result of operations.
-       * @param message - The error message.
-       * @param operation - The operation name.
-       * @param statusCode - The operation result as a numerical status code.
-       * @param flags - Flags that characterize the error. See {@link FlaggedError.FLAGS}.
-       */
-    constructor(
-        message?: string,
-        public operation?: string,
-        public statusCode?: number,
-        public flags: number = 0,
-    ) {
-        super(message);
-        Object.setPrototypeOf(this, OperationError.prototype);
-        this.name = "OperationError";
-        this.stack = Error(message).stack;
-    }
+	/**
+	 * Instantiates an OperationError, which mimics the Error class with added properties
+	 * meant for reporting the result of operations.
+	 * @param message - The error message.
+	 * @param operation - The operation name.
+	 * @param statusCode - The operation result as a numerical status code.
+	 * @param flags - Flags that characterize the error. See {@link FlaggedError.FLAGS}.
+	 */
+	constructor(
+		message?: string,
+		public operation?: string,
+		public statusCode?: number,
+		public flags: number = 0,
+	) {
+		super(message);
+		Object.setPrototypeOf(this, OperationError.prototype);
+		this.name = "OperationError";
+		this.stack = Error(message).stack;
+	}
 
-    isQuiet() {
-        return FlaggedError.prototype.isQuiet.call(this);
-    }
+	isQuiet() {
+		return FlaggedError.prototype.isQuiet.call(this);
+	}
 
-    isTransient() {
-        return FlaggedError.prototype.isTransient.call(this);
-    }
+	isTransient() {
+		return FlaggedError.prototype.isTransient.call(this);
+	}
 
-    /**
-     * @returns A string representation of the error flags.
-     */
-    private _flagsToString() {
-        const flagArray: string[] = [];
-        _.mapValues(FlaggedError.FLAGS, (flagValue, flagName) => {
-            // eslint-disable-next-line no-bitwise
-            if ((this.flags & flagValue) === flagValue) {
-                flagArray.push(flagName);
-            }
-        });
-        return `${this.flags} [${flagArray.join(",")}]`;
-    }
+	/**
+	 * @returns A string representation of the error flags.
+	 */
+	private _flagsToString() {
+		const flagArray: string[] = [];
+		_.mapValues(FlaggedError.FLAGS, (flagValue, flagName) => {
+			// eslint-disable-next-line no-bitwise
+			if ((this.flags & flagValue) === flagValue) {
+				flagArray.push(flagName);
+			}
+		});
+		return `${this.flags} [${flagArray.join(",")}]`;
+	}
 
-    toString(): string {
-        const extendedFieldsArray: string[] = [];
-        if (this.operation !== undefined) {
-            extendedFieldsArray.push(this.operation);
-        }
+	toString(): string {
+		const extendedFieldsArray: string[] = [];
+		if (this.operation !== undefined) {
+			extendedFieldsArray.push(this.operation);
+		}
 
-        if (this.statusCode !== undefined) {
-            extendedFieldsArray.push(this.statusCode.toString());
-        }
+		if (this.statusCode !== undefined) {
+			extendedFieldsArray.push(this.statusCode.toString());
+		}
 
-        if (this.flags) {
-            extendedFieldsArray.push(this._flagsToString.call(this));
-        }
+		if (this.flags) {
+			extendedFieldsArray.push(this._flagsToString.call(this));
+		}
 
-        let msg = this.name;
+		let msg = this.name;
 
-        if (extendedFieldsArray.length > 0) {
-            msg += `[${extendedFieldsArray.join(", ")}]`;
-        }
+		if (extendedFieldsArray.length > 0) {
+			msg += `[${extendedFieldsArray.join(", ")}]`;
+		}
 
-        msg += `: ${this.message}`;
+		msg += `: ${this.message}`;
 
-        if (this.stack !== undefined) {
-            msg += `, stack: ${this.stack}`;
-        }
+		if (this.stack !== undefined) {
+			msg += `, stack: ${this.stack}`;
+		}
 
-        return msg;
-    }
+		return msg;
+	}
 }