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

package/src/guidUtils.ts

@@ -21,74 +21,74 @@ const UINT_32HASH_PRIME = 16777619;
  * Page 357, algorithm name: Ranlim32
  */
 const guidRNG = {
-    u: 0,
-    v: 0,
-    w1: 0,
-    w2: 0,
-    isInitialized: false,
-
-    /**
-     * Initialize RNG.
-     * This function need to be called once, before the first GUID gets created.
-     *
-     * @param in_seed - Optional 32-bit seed for GUID RNG.
-     * If no seed is given, a combination of system's local time and `Math.random()` is used.
-     * @param in_enforceReInitialization - Optionally enforce re-initialization with another seed.
-     *
-     * @returns The seed used to initialize the RNG;
-     * If re-initialization is not enforced, a zero indicates that the RNG was not re-seeded.
-     *
-     * @alias property-common.initializeGUIDGenerator
-     */
-    initialize(in_seed?: number, in_enforceReInitialization: boolean = false): number {
-        // Quit if the RNG has already been initialized and we do not
-        // want to enforce a re-initialization with a new seed
-        if (this.isInitialized && !in_enforceReInitialization) {
-            return 0;
-        } else {
-            this.isInitialized = true;
-
-            if (in_seed === undefined) {
-                const randomValues = generateRandomUInt32Array(4);
-                this.u = randomValues[0];
-                this.v = randomValues[1];
-                this.w1 = randomValues[2];
-                this.w2 = randomValues[3];
-            } else {
-                this.v = 224461437;
-                this.w1 = 521288629;
-                this.w2 = 362436069;
-
-                this.u = in_seed ^ this.v;
-                this.genRandUInt32();
-                this.v = this.u;
-                this.genRandUInt32();
-            }
-            return -1;
-        }
-    },
-
-    /**
-     * @returns 32-bit random number based on the RNGs internal state
-     */
-    genRandUInt32(): number {
-        this.u = multiply_uint32(this.u, 2891336453) + 1640531513;
-        this.v ^= this.v >>> 13;
-        this.v ^= this.v << 17;
-        this.v = ((this.v >>> 5) ^ this.v) >>> 0;
-
-        this.w1 = multiply_uint32(33378, (this.w1 & 0xffff)) + (this.w1 >>> 16);
-        this.w2 = multiply_uint32(57225, (this.w2 & 0xffff)) + (this.w2 >>> 16);
-
-        let x = this.u ^ (this.u << 9);
-        x ^= x >>> 17;
-        x ^= x << 6;
-
-        let y = this.w1 ^ (this.w1 << 17);
-        y ^= y >>> 15;
-        y ^= y << 5;
-        return (((x >>> 0) + this.v) ^ ((y >>> 0) + this.w2)) >>> 0;
-    },
+	u: 0,
+	v: 0,
+	w1: 0,
+	w2: 0,
+	isInitialized: false,
+
+	/**
+	 * Initialize RNG.
+	 * This function need to be called once, before the first GUID gets created.
+	 *
+	 * @param in_seed - Optional 32-bit seed for GUID RNG.
+	 * If no seed is given, a combination of system's local time and `Math.random()` is used.
+	 * @param in_enforceReInitialization - Optionally enforce re-initialization with another seed.
+	 *
+	 * @returns The seed used to initialize the RNG;
+	 * If re-initialization is not enforced, a zero indicates that the RNG was not re-seeded.
+	 *
+	 * @alias property-common.initializeGUIDGenerator
+	 */
+	initialize(in_seed?: number, in_enforceReInitialization: boolean = false): number {
+		// Quit if the RNG has already been initialized and we do not
+		// want to enforce a re-initialization with a new seed
+		if (this.isInitialized && !in_enforceReInitialization) {
+			return 0;
+		} else {
+			this.isInitialized = true;
+
+			if (in_seed === undefined) {
+				const randomValues = generateRandomUInt32Array(4);
+				this.u = randomValues[0];
+				this.v = randomValues[1];
+				this.w1 = randomValues[2];
+				this.w2 = randomValues[3];
+			} else {
+				this.v = 224461437;
+				this.w1 = 521288629;
+				this.w2 = 362436069;
+
+				this.u = in_seed ^ this.v;
+				this.genRandUInt32();
+				this.v = this.u;
+				this.genRandUInt32();
+			}
+			return -1;
+		}
+	},
+
+	/**
+	 * @returns 32-bit random number based on the RNGs internal state
+	 */
+	genRandUInt32(): number {
+		this.u = multiply_uint32(this.u, 2891336453) + 1640531513;
+		this.v ^= this.v >>> 13;
+		this.v ^= this.v << 17;
+		this.v = ((this.v >>> 5) ^ this.v) >>> 0;
+
+		this.w1 = multiply_uint32(33378, this.w1 & 0xffff) + (this.w1 >>> 16);
+		this.w2 = multiply_uint32(57225, this.w2 & 0xffff) + (this.w2 >>> 16);
+
+		let x = this.u ^ (this.u << 9);
+		x ^= x >>> 17;
+		x ^= x << 6;
+
+		let y = this.w1 ^ (this.w1 << 17);
+		y ^= y >>> 15;
+		y ^= y << 5;
+		return (((x >>> 0) + this.v) ^ ((y >>> 0) + this.w2)) >>> 0;
+	},
 };
 
 /**
@@ -108,13 +108,13 @@ const isBase64 = (GUID: string): boolean => GUID.length === 22;
  * @returns - result of unsigned integer multiplication
  */
 function multiply_uint32(a: number, b: number): number {
-    let n = a;
-    let m = b;
+	let n = a;
+	let m = b;
 
-    n >>>= 0;
-    m >>>= 0;
-    const nlo = n & 0xffff;
-    return (((n - nlo) * m >>> 0) + (nlo * m)) >>> 0;
+	n >>>= 0;
+	m >>>= 0;
+	const nlo = n & 0xffff;
+	return ((((n - nlo) * m) >>> 0) + nlo * m) >>> 0;
 }
 
 /**
@@ -124,7 +124,8 @@ function multiply_uint32(a: number, b: number): number {
  *
  * @returns Url-friendly base64 encoding.
  */
-const toUrlBase64 = (base64: string): string => base64.replace(/\+/g, "-").replace(/\//g, "_").split("=")[0];
+const toUrlBase64 = (base64: string): string =>
+	base64.replace(/\+/g, "-").replace(/\//g, "_").split("=")[0];
 
 /**
  * Helper function to recover padding of base64 encoding
@@ -133,11 +134,11 @@ const toUrlBase64 = (base64: string): string => base64.replace(/\+/g, "-").repla
  *
  * @returns Padded base64 encoding.
  */
-const toPaddedBase64 = function(x: string): string {
-    let base64 = x;
-    const padLength = 4 - base64.length % 4;
-    base64 += "=".repeat(padLength);
-    return base64;
+const toPaddedBase64 = function (x: string): string {
+	let base64 = x;
+	const padLength = 4 - (base64.length % 4);
+	base64 += "=".repeat(padLength);
+	return base64;
 };
 
 /**
@@ -148,23 +149,28 @@ const toPaddedBase64 = function(x: string): string {
  *
  * @returns The GUID
  */
-const uint32x4ToGUID = function(in_guidArray: Uint32Array | Int32Array | number[], base64: boolean = false): string {
-    if (base64) {
-        const intArray = new Uint32Array(in_guidArray);
-        const byteArray = new Uint8Array(intArray.buffer);
-        const base64guid = base64js.fromByteArray(byteArray);
-        // return url-friendly base64
-        return toUrlBase64(base64guid);
-    } else {
-        // Convert to hexadecimal string
-        let str = "";
-        for (let i = 0; i < 4; i++) {
-            const hex = in_guidArray[i].toString(16);
-            str += ("0".repeat(8 - hex.length) + hex);
-        }
-        // eslint-disable-next-line max-len
-        return `${str.substr(0, 8)}-${str.substr(8, 4)}-${str.substr(12, 4)}-${str.substr(16, 4)}-${str.substr(20, 12)}`;
-    }
+const uint32x4ToGUID = function (
+	in_guidArray: Uint32Array | Int32Array | number[],
+	base64: boolean = false,
+): string {
+	if (base64) {
+		const intArray = new Uint32Array(in_guidArray);
+		const byteArray = new Uint8Array(intArray.buffer);
+		const base64guid = base64js.fromByteArray(byteArray);
+		// return url-friendly base64
+		return toUrlBase64(base64guid);
+	} else {
+		// Convert to hexadecimal string
+		let str = "";
+		for (let i = 0; i < 4; i++) {
+			const hex = in_guidArray[i].toString(16);
+			str += "0".repeat(8 - hex.length) + hex;
+		}
+		return `${str.substr(0, 8)}-${str.substr(8, 4)}-${str.substr(12, 4)}-${str.substr(
+			16,
+			4,
+		)}-${str.substr(20, 12)}`;
+	}
 };
 
 /**
@@ -176,19 +182,22 @@ const uint32x4ToGUID = function(in_guidArray: Uint32Array | Int32Array | number[
  * @returns Four 32-bit values
  *
  */
-const guidToUint32x4 = function(in_guid: string, result: Uint32Array = new Uint32Array(4)): Uint32Array {
-    if (isBase64(in_guid)) {
-        const GUID = toPaddedBase64(in_guid);
-        const bytes = base64js.toByteArray(GUID);
-        const intArray = new Uint32Array(bytes.buffer);
-        result.set(intArray);
-    } else {
-        result[0] = parseInt(`0x${in_guid.substr(0, 8)}`, 16);
-        result[1] = parseInt(`0x${in_guid.substr(9, 4)}${in_guid.substr(14, 4)}`, 16);
-        result[2] = parseInt(`0x${in_guid.substr(19, 4)}${in_guid.substr(24, 4)}`, 16);
-        result[3] = parseInt(`0x${in_guid.substr(28, 8)}`, 16);
-    }
-    return result;
+const guidToUint32x4 = function (
+	in_guid: string,
+	result: Uint32Array = new Uint32Array(4),
+): Uint32Array {
+	if (isBase64(in_guid)) {
+		const GUID = toPaddedBase64(in_guid);
+		const bytes = base64js.toByteArray(GUID);
+		const intArray = new Uint32Array(bytes.buffer);
+		result.set(intArray);
+	} else {
+		result[0] = parseInt(`0x${in_guid.substr(0, 8)}`, 16);
+		result[1] = parseInt(`0x${in_guid.substr(9, 4)}${in_guid.substr(14, 4)}`, 16);
+		result[2] = parseInt(`0x${in_guid.substr(19, 4)}${in_guid.substr(24, 4)}`, 16);
+		result[3] = parseInt(`0x${in_guid.substr(28, 8)}`, 16);
+	}
+	return result;
 };
 
 /**
@@ -220,23 +229,23 @@ const base16ToBase64 = (in_guid: string) => uint32x4ToGUID(guidToUint32x4(in_gui
  *
  * @returns The GUID
  */
-const generateGUID = function(base64 = false): string {
-    const rnds = new Uint32Array(4);
-
-    // Random numbers for GUID (4x32 bit)
-    rnds[0] = guidRNG.genRandUInt32();
-    rnds[1] = guidRNG.genRandUInt32();
-    rnds[2] = guidRNG.genRandUInt32();
-    rnds[3] = guidRNG.genRandUInt32();
-    return uint32x4ToGUID(rnds, base64);
+const generateGUID = function (base64 = false): string {
+	const rnds = new Uint32Array(4);
+
+	// Random numbers for GUID (4x32 bit)
+	rnds[0] = guidRNG.genRandUInt32();
+	rnds[1] = guidRNG.genRandUInt32();
+	rnds[2] = guidRNG.genRandUInt32();
+	rnds[3] = guidRNG.genRandUInt32();
+	return uint32x4ToGUID(rnds, base64);
 };
 
 // The last character is checked this way because last 4 bits of 22nd character are ignored
 // by decoder, e.g. "+Q" and "+Z" result in the same decoding.
 // The only characters with last 4 bits set to 0 are A, Q, g, w.
-const reBase64 = (/^[\w-]{21}[AQgw]$/);
+const reBase64 = /^[\w-]{21}[AQgw]$/;
 // eslint-disable-next-line unicorn/no-unsafe-regex
-const reBase16 = (/^[\dA-Fa-f]{8}(?:-[\dA-Fa-f]{4}){3}-[\dA-Fa-f]{12}$/);
+const reBase16 = /^[\dA-Fa-f]{8}(?:-[\dA-Fa-f]{4}){3}-[\dA-Fa-f]{12}$/;
 
 /**
  * Routine used to check whether the given string is a valid GUID
@@ -254,42 +263,42 @@ const isGUID = (in_guid: string) => reBase16.test(in_guid) || reBase64.test(in_g
  * @param in_array2 - Second array
  * @returns New combined hash
  */
-const hashCombine4xUint32 = function(
-    in_array1: Uint32Array,
-    in_array2: Uint32Array,
-    io_result?: Uint32Array,
+const hashCombine4xUint32 = function (
+	in_array1: Uint32Array,
+	in_array2: Uint32Array,
+	io_result?: Uint32Array,
 ): Uint32Array {
-    let accumulated = io_result;
-    if (accumulated === undefined) {
-        accumulated = new Uint32Array(in_array2);
-    } else {
-        accumulated[0] = in_array2[0];
-        accumulated[1] = in_array2[1];
-        accumulated[2] = in_array2[2];
-        accumulated[3] = in_array2[3];
-    }
-
-    accumulated[0] += 0x9e3779b9;
-    accumulated[1] += 0x638f227;
-    accumulated[2] += 0x1aff2bad;
-    accumulated[3] += 0x3a8f05c5;
-
-    accumulated[0] += in_array1[3] << 6;
-    accumulated[1] += in_array1[0] << 6;
-    accumulated[2] += in_array1[1] << 6;
-    accumulated[3] += in_array1[2] << 6;
-
-    accumulated[0] += in_array1[2] >> 2;
-    accumulated[1] += in_array1[3] >> 2;
-    accumulated[2] += in_array1[0] >> 2;
-    accumulated[3] += in_array1[1] >> 2;
-
-    accumulated[0] = ((accumulated[0] ^ in_array1[1]) * UINT_32HASH_PRIME) >>> 0;
-    accumulated[1] = ((accumulated[1] ^ in_array1[2]) * UINT_32HASH_PRIME) >>> 0;
-    accumulated[2] = ((accumulated[2] ^ in_array1[3]) * UINT_32HASH_PRIME) >>> 0;
-    accumulated[3] = ((accumulated[3] ^ in_array1[0]) * UINT_32HASH_PRIME) >>> 0;
-
-    return accumulated;
+	let accumulated = io_result;
+	if (accumulated === undefined) {
+		accumulated = new Uint32Array(in_array2);
+	} else {
+		accumulated[0] = in_array2[0];
+		accumulated[1] = in_array2[1];
+		accumulated[2] = in_array2[2];
+		accumulated[3] = in_array2[3];
+	}
+
+	accumulated[0] += 0x9e3779b9;
+	accumulated[1] += 0x638f227;
+	accumulated[2] += 0x1aff2bad;
+	accumulated[3] += 0x3a8f05c5;
+
+	accumulated[0] += in_array1[3] << 6;
+	accumulated[1] += in_array1[0] << 6;
+	accumulated[2] += in_array1[1] << 6;
+	accumulated[3] += in_array1[2] << 6;
+
+	accumulated[0] += in_array1[2] >> 2;
+	accumulated[1] += in_array1[3] >> 2;
+	accumulated[2] += in_array1[0] >> 2;
+	accumulated[3] += in_array1[1] >> 2;
+
+	accumulated[0] = ((accumulated[0] ^ in_array1[1]) * UINT_32HASH_PRIME) >>> 0;
+	accumulated[1] = ((accumulated[1] ^ in_array1[2]) * UINT_32HASH_PRIME) >>> 0;
+	accumulated[2] = ((accumulated[2] ^ in_array1[3]) * UINT_32HASH_PRIME) >>> 0;
+	accumulated[3] = ((accumulated[3] ^ in_array1[0]) * UINT_32HASH_PRIME) >>> 0;
+
+	return accumulated;
 };
 
 /**
@@ -303,26 +312,28 @@ const hashCombine4xUint32 = function(
  * @param base64 - Use base64 encoding instead of standart GUIDs
  * @returns Combined GUID
  */
-const combineGuids = function(in_guid1: string, in_guid2: string, base64 = false): string {
-    const firstArray = guidToUint32x4(in_guid1);
-    const secondArray = guidToUint32x4(in_guid2);
-    const combined = hashCombine4xUint32(firstArray, secondArray);
-    return uint32x4ToGUID(combined, base64);
+const combineGuids = function (in_guid1: string, in_guid2: string, base64 = false): string {
+	const firstArray = guidToUint32x4(in_guid1);
+	const secondArray = guidToUint32x4(in_guid2);
+	const combined = hashCombine4xUint32(firstArray, secondArray);
+	return uint32x4ToGUID(combined, base64);
 };
 
 // Make sure the RNG is initialized
 guidRNG.initialize();
 
-const initializeGUIDGenerator = (...args) => { guidRNG.initialize(...args); };
+const initializeGUIDGenerator = (...args) => {
+	guidRNG.initialize(...args);
+};
 
 export const GuidUtils = {
-    uint32x4ToGUID,
-    guidToUint32x4,
-    base64Tobase16,
-    base16ToBase64,
-    initializeGUIDGenerator,
-    generateGUID,
-    isGUID,
-    combineGuids,
-    hashCombine4xUint32,
+	uint32x4ToGUID,
+	guidToUint32x4,
+	base64Tobase16,
+	base16ToBase64,
+	initializeGUIDGenerator,
+	generateGUID,
+	isGUID,
+	combineGuids,
+	hashCombine4xUint32,
 };

package/src/hashCalculator.ts

@@ -11,6 +11,9 @@
 import murmurHash3 from "murmurhash3js";
 
 export function calculateHash(key, seed = 0) {
-    const str = murmurHash3.x86.hash128(key, seed);
-    return `${str.substr(0, 8)}-${str.substr(8, 4)}-${str.substr(12, 4)}-${str.substr(16, 4)}-${str.substr(20, 12)}`;
+	const str = murmurHash3.x86.hash128(key, seed);
+	return `${str.substr(0, 8)}-${str.substr(8, 4)}-${str.substr(12, 4)}-${str.substr(
+		16,
+		4,
+	)}-${str.substr(20, 12)}`;
 }

package/src/joinPaths.ts

@@ -17,14 +17,20 @@
  *
  * @returns The joined path
  */
-export function joinPaths(in_string1: string = "", in_string2: string = "", in_separator: string = "/"): string {
-    let separator = in_separator;
+export function joinPaths(
+	in_string1: string = "",
+	in_string2: string = "",
+	in_separator: string = "/",
+): string {
+	let separator = in_separator;
 
-    if (!in_string1 ||
-        !in_string2 ||
-        in_string1.substr(-in_separator.length) === in_separator ||
-        in_string2.substr(0, in_separator.length) === in_separator) {
-        separator = "";
-    }
-    return in_string1 + separator + in_string2;
+	if (
+		!in_string1 ||
+		!in_string2 ||
+		in_string1.substr(-in_separator.length) === in_separator ||
+		in_string2.substr(0, in_separator.length) === in_separator
+	) {
+		separator = "";
+	}
+	return in_string1 + separator + in_string2;
 }

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluid-experimental/property-common";
-export const pkgVersion = "2.0.0-dev.2.3.0.115467";
+export const pkgVersion = "2.0.0-dev.4.1.0.148229";

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",
-    "compilerOptions": {
-        "composite": true,
-        "rootDir": "./src",
-        "outDir": "./dist"
-    },
-    "include": [
-        "src/**/*"
-    ],
-    "exclude": [
-        "src/test/**/*"
-    ]
-}
+	"extends": "@fluidframework/build-common/ts-common-config.json",
+	"compilerOptions": {
+		"composite": true,
+		"rootDir": "./src",
+		"outDir": "./dist",
+	},
+	"include": ["src/**/*"],
+	"exclude": ["src/test/**/*"],
+}