@fluidframework/container-runtime 2.0.0-internal.6.1.0 → 2.0.0-internal.6.2.0

package/src/id-compressor/utils.ts

@@ -1,114 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-/**
- * Remove `readonly` from all fields.
- */
-export type Mutable<T> = { -readonly [P in keyof T]: T[P] };
-
-/** A union type of the first `N` positive integers */
-export type TakeWholeNumbers<N extends number, A extends never[] = []> = N extends A["length"]
-	? never
-	: A["length"] | TakeWholeNumbers<N, [never, ...A]>;
-
-/** Returns a tuple type with exactly `Length` elements of type `T` */
-export type ArrayOfLength<T, Length extends number, A extends T[] = []> = Length extends A["length"]
-	? A
-	: ArrayOfLength<T, Length, [T, ...A]>;
-
-/**
- * Fails true iff `array` has at least `length` elements
- */
-export function hasAtLeastLength<T, Len extends TakeWholeNumbers<16>>(
-	array: readonly T[],
-	length: Len,
-): array is [...ArrayOfLength<T, Len>, ...T[]] {
-	return array.length >= length;
-}
-
-/**
- * A numeric comparator used for sorting in ascending order.
- *
- * Handles +/-0 like Map: -0 is equal to +0.
- */
-export function compareFiniteNumbers<T extends number>(a: T, b: T): number {
-	return a - b;
-}
-
-/**
- * A numeric comparator used for sorting in descending order.
- *
- * Handles +/-0 like Map: -0 is equal to +0.
- */
-export function compareFiniteNumbersReversed<T extends number>(a: T, b: T): number {
-	return b - a;
-}
-
-/**
- * Compare two maps and return true if their contents are equivalent.
- * @param mapA - The first array to compare
- * @param mapB - The second array to compare
- * @param elementComparator - The function used to check if two `T`s are equivalent.
- * Defaults to `Object.is()` equality (a shallow compare)
- */
-export function compareMaps<K, V>(
-	mapA: ReadonlyMap<K, V>,
-	mapB: ReadonlyMap<K, V>,
-	elementComparator: (a: V, b: V) => boolean = Object.is,
-): boolean {
-	if (mapA.size !== mapB.size) {
-		return false;
-	}
-
-	for (const [keyA, valueA] of mapA) {
-		const valueB = mapB.get(keyA);
-		if (valueB === undefined || !elementComparator(valueA, valueB)) {
-			return false;
-		}
-	}
-
-	return true;
-}
-
-/**
- * Retrieve a value from a map with the given key, or create a new entry if the key is not in the map.
- * @param map - The map to query/update
- * @param key - The key to lookup in the map
- * @param defaultValue - a function which returns a default value. This is called and used to set an initial value for the given key in the map if none exists
- * @returns either the existing value for the given key, or the newly-created value (the result of `defaultValue`)
- */
-export function getOrCreate<K, V>(map: Map<K, V>, key: K, defaultValue: (key: K) => V): V {
-	let value = map.get(key);
-	if (value === undefined) {
-		value = defaultValue(key);
-		map.set(key, value);
-	}
-	return value;
-}
-
-/**
- * Compares strings lexically to form a strict partial ordering.
- */
-export function compareStrings<T extends string>(a: T, b: T): number {
-	return a > b ? 1 : a === b ? 0 : -1;
-}
-
-export function fail(message: string): never {
-	throw new Error(message);
-}
-
-/**
- * Sets a property in such a way that it is only set on `destination` if the provided value is not undefined.
- * This avoids having explicit undefined values under properties that would cause `Object.hasOwnProperty` to return true.
- */
-export function setPropertyIfDefined<TDst, P extends keyof TDst>(
-	value: TDst[P] | undefined,
-	destination: TDst,
-	property: P,
-): void {
-	if (value !== undefined) {
-		destination[property] = value;
-	}
-}

package/src/id-compressor/uuidUtilities.ts

@@ -1,120 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-
-import { assert } from "@fluidframework/common-utils";
-import { StableId, UuidString } from "@fluidframework/runtime-definitions";
-import { v4 } from "uuid";
-
-const hexadecimalCharCodes = Array.from("09afAF").map((c) => c.charCodeAt(0)) as [
-	zero: number,
-	nine: number,
-	a: number,
-	f: number,
-	A: number,
-	F: number,
-];
-
-function isHexadecimalCharacter(charCode: number): boolean {
-	return (
-		(charCode >= hexadecimalCharCodes[0] && charCode <= hexadecimalCharCodes[1]) ||
-		(charCode >= hexadecimalCharCodes[2] && charCode <= hexadecimalCharCodes[3]) ||
-		(charCode >= hexadecimalCharCodes[4] && charCode <= hexadecimalCharCodes[5])
-	);
-}
-
-/**
- * Asserts that the given string is a UUID
- */
-export function assertIsUuidString(uuidString: string): UuidString {
-	assert(isUuidString(uuidString), 0x4a2 /* Expected an UuidString */);
-	return uuidString;
-}
-
-/**
- * Returns true iff the given string is a valid UUID-like string of hexadecimal characters
- * 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
- */
-export function isUuidString(str: string): str is UuidString {
-	for (let i = 0; i < str.length; i++) {
-		switch (i) {
-			case 8:
-			case 13:
-			case 18:
-			case 23:
-				if (str.charAt(i) !== "-") {
-					return false;
-				}
-				break;
-
-			default:
-				if (!isHexadecimalCharacter(str.charCodeAt(i))) {
-					return false;
-				}
-				break;
-		}
-	}
-
-	return true;
-}
-
-/**
- * Generate a random stable ID
- */
-export function generateStableId(): StableId {
-	return assertIsStableId(v4());
-}
-
-/**
- * Asserts that the given string is a stable ID.
- */
-export function assertIsStableId(stableId: string): StableId {
-	assert(isStableId(stableId), 0x4a3 /* Expected a StableId */);
-	return stableId;
-}
-
-/**
- * Returns true iff the given string is a valid Version 4, variant 2 UUID
- * 'xxxxxxxx-xxxx-4xxx-vxxx-xxxxxxxxxxxx'
- */
-export function isStableId(str: string): str is StableId {
-	if (str.length !== 36) {
-		return false;
-	}
-
-	for (let i = 0; i < str.length; i++) {
-		switch (i) {
-			case 8:
-			case 13:
-			case 18:
-			case 23:
-				if (str.charAt(i) !== "-") {
-					return false;
-				}
-				break;
-
-			case 14:
-				if (str.charAt(i) !== "4") {
-					return false;
-				}
-				break;
-
-			case 19: {
-				const char = str.charAt(i);
-				if (char !== "8" && char !== "9" && char !== "a" && char !== "b") {
-					return false;
-				}
-				break;
-			}
-
-			default:
-				if (!isHexadecimalCharacter(str.charCodeAt(i))) {
-					return false;
-				}
-				break;
-		}
-	}
-
-	return true;
-}