@tutao/tutanota-utils 3.94.0 → 3.94.1

package/dist/ArrayUtils.js

@@ -1,20 +1,20 @@
-import { downcast, identity, neverNull } from "./Utils.js"
-import { getFromMap } from "./MapUtils.js"
+import { downcast, identity, neverNull } from "./Utils.js";
+import { getFromMap } from "./MapUtils.js";
 export function concat(...arrays) {
-	let length = arrays.reduce((previous, current) => previous + current.length, 0)
-	let result = new Uint8Array(length)
-	let index = 0
-	arrays.forEach(array => {
-		result.set(array, index)
-		index += array.length
-	})
-	return result
+    let length = arrays.reduce((previous, current) => previous + current.length, 0);
+    let result = new Uint8Array(length);
+    let index = 0;
+    arrays.forEach(array => {
+        result.set(array, index);
+        index += array.length;
+    });
+    return result;
 }
 /**
  * Create an array filled with the numbers min..max (inclusive)
  */
 export function numberRange(min, max) {
-	return [...Array(max + 1).keys()].slice(min)
+    return [...Array(max + 1).keys()].slice(min);
 }
 /**
  * Compares two arrays for equality based on ===.
@@ -25,18 +25,18 @@ export function numberRange(min, max) {
  * It is valid to compare Uint8Array to Array<T>, don't restrict it to be one type
  */
 export function arrayEquals(a1, a2) {
-	if (a1 === a2) {
-		return true
-	}
-	if (a1.length === a2.length) {
-		for (let i = 0; i < a1.length; i++) {
-			if (a1[i] !== a2[i]) {
-				return false
-			}
-		}
-		return true
-	}
-	return false
+    if (a1 === a2) {
+        return true;
+    }
+    if (a1.length === a2.length) {
+        for (let i = 0; i < a1.length; i++) {
+            if (a1[i] !== a2[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
 }
 /**
  * Compares two arrays for equality based on a predicate
@@ -46,24 +46,24 @@ export function arrayEquals(a1, a2) {
  * @returns {boolean}
  */
 export function arrayEqualsWithPredicate(a1, a2, predicate) {
-	if (a1.length === a2.length) {
-		for (let i = 0; i < a1.length; i++) {
-			if (!predicate(a1[i], a2[i])) {
-				return false
-			}
-		}
-		return true
-	}
-	return false
+    if (a1.length === a2.length) {
+        for (let i = 0; i < a1.length; i++) {
+            if (!predicate(a1[i], a2[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
 }
 export function arrayHash(array) {
-	let hash = 0
-	hash |= 0
-	for (let i = 0; i < array.length; i++) {
-		hash = (hash << 5) - hash + array[i]
-		hash |= 0 // Convert to 32bit integer
-	}
-	return hash
+    let hash = 0;
+    hash |= 0;
+    for (let i = 0; i < array.length; i++) {
+        hash = (hash << 5) - hash + array[i];
+        hash |= 0; // Convert to 32bit integer
+    }
+    return hash;
 }
 /**
  * Remove the element from theArray if it is contained in the array.
@@ -72,25 +72,26 @@ export function arrayHash(array) {
  * @return True if the element was removed, false otherwise.
  */
 export function remove(theArray, elementToRemove) {
-	let i = theArray.indexOf(elementToRemove)
-	if (i !== -1) {
-		theArray.splice(i, 1)
-		return true
-	} else {
-		return false
-	}
+    let i = theArray.indexOf(elementToRemove);
+    if (i !== -1) {
+        theArray.splice(i, 1);
+        return true;
+    }
+    else {
+        return false;
+    }
 }
 /**
  * Find all items in an array that pass the given predicate
  */
 export function findAll(theArray, finder) {
-	const found = []
-	for (let element of theArray) {
-		if (finder(element)) {
-			found.push(element)
-		}
-	}
-	return found
+    const found = [];
+    for (let element of theArray) {
+        if (finder(element)) {
+            found.push(element);
+        }
+    }
+    return found;
 }
 /**
  * @param theArray
@@ -98,48 +99,50 @@ export function findAll(theArray, finder) {
  * @return {boolean} if the element was found
  */
 export function findAndRemove(theArray, finder) {
-	const index = theArray.findIndex(finder)
-	if (index !== -1) {
-		theArray.splice(index, 1)
-		return true
-	} else {
-		return false
-	}
+    const index = theArray.findIndex(finder);
+    if (index !== -1) {
+        theArray.splice(index, 1);
+        return true;
+    }
+    else {
+        return false;
+    }
 }
 export function findAllAndRemove(theArray, finder, startIndex = 0) {
-	var removedElement = false
-	for (let i = theArray.length - 1; i >= startIndex; i--) {
-		if (finder(theArray[i])) {
-			theArray.splice(i, 1)
-			removedElement = true
-		}
-	}
-	return removedElement
+    var removedElement = false;
+    for (let i = theArray.length - 1; i >= startIndex; i--) {
+        if (finder(theArray[i])) {
+            theArray.splice(i, 1);
+            removedElement = true;
+        }
+    }
+    return removedElement;
 }
 export function replace(theArray, oldElement, newElement) {
-	let i = theArray.indexOf(oldElement)
-	if (i !== -1) {
-		theArray.splice(i, 1, newElement)
-		return true
-	} else {
-		return false
-	}
+    let i = theArray.indexOf(oldElement);
+    if (i !== -1) {
+        theArray.splice(i, 1, newElement);
+        return true;
+    }
+    else {
+        return false;
+    }
 }
 /**
  * Same as filterMap in some languages. Apply mapper and then only include non-nullable items.
  */
 export function mapAndFilterNull(array, mapper) {
-	const resultList = []
-	for (const item of array) {
-		const resultItem = mapper(item)
-		if (resultItem != null) {
-			resultList.push(resultItem)
-		}
-	}
-	return resultList
+    const resultList = [];
+    for (const item of array) {
+        const resultItem = mapper(item);
+        if (resultItem != null) {
+            resultList.push(resultItem);
+        }
+    }
+    return resultList;
 }
 export function filterNull(array) {
-	return downcast(array.filter(item => item != null))
+    return downcast(array.filter(item => item != null));
 }
 /**
  * Provides the last element of the given array.
@@ -147,62 +150,62 @@ export function filterNull(array) {
  * @return The last element of the array.
  */
 export function last(theArray) {
-	return theArray[theArray.length - 1]
+    return theArray[theArray.length - 1];
 }
 export function isEmpty(array) {
-	return array.length === 0
+    return array.length === 0;
 }
 export function lastThrow(array) {
-	if (isEmpty(array)) {
-		throw new RangeError("Array is empty")
-	}
-	return neverNull(last(array))
+    if (isEmpty(array)) {
+        throw new RangeError("Array is empty");
+    }
+    return neverNull(last(array));
 }
 export function firstThrow(array) {
-	if (isEmpty(array)) {
-		throw new RangeError("Array is empty")
-	}
-	return array[0]
+    if (isEmpty(array)) {
+        throw new RangeError("Array is empty");
+    }
+    return array[0];
 }
 export function first(array) {
-	return array[0] || null
+    return array[0] || null;
 }
 export function findLast(array, predicate) {
-	const index = findLastIndex(array, predicate)
-	if (index !== -1) {
-		return array[index]
-	}
-	return null
+    const index = findLastIndex(array, predicate);
+    if (index !== -1) {
+        return array[index];
+    }
+    return null;
 }
 export function findLastIndex(array, predicate) {
-	for (let i = array.length - 1; i >= 0; i--) {
-		if (predicate(array[i])) {
-			return i
-		}
-	}
-	return -1
+    for (let i = array.length - 1; i >= 0; i--) {
+        if (predicate(array[i])) {
+            return i;
+        }
+    }
+    return -1;
 }
 export function contains(theArray, elementToCheck) {
-	return theArray.indexOf(elementToCheck) !== -1
+    return theArray.indexOf(elementToCheck) !== -1;
 }
 export function addAll(array, elements) {
-	array.push(...elements)
+    array.push(...elements);
 }
 export function removeAll(array, elements) {
-	elements.forEach(element => {
-		remove(array, element)
-	})
+    elements.forEach(element => {
+        remove(array, element);
+    });
 }
 /**
  * Group an array based on the given discriminator, but each group will have only unique items
  */
 export function groupByAndMapUniquely(iterable, discriminator, mapper) {
-	const map = new Map()
-	for (let el of iterable) {
-		const key = discriminator(el)
-		getFromMap(map, key, () => new Set()).add(mapper(el))
-	}
-	return map
+    const map = new Map();
+    for (let el of iterable) {
+        const key = discriminator(el);
+        getFromMap(map, key, () => new Set()).add(mapper(el));
+    }
+    return map;
 }
 /**
  * convert an Array of T's into a Map of Arrays of E's by
@@ -214,12 +217,12 @@ export function groupByAndMapUniquely(iterable, discriminator, mapper) {
  * @returns {Map<R, Array<E>>}
  */
 export function groupByAndMap(iterable, discriminator, mapper) {
-	const map = new Map()
-	for (let el of iterable) {
-		const key = discriminator(el)
-		getFromMap(map, key, () => []).push(mapper(el))
-	}
-	return map
+    const map = new Map();
+    for (let el of iterable) {
+        const key = discriminator(el);
+        getFromMap(map, key, () => []).push(mapper(el));
+    }
+    return map;
 }
 /**
  * Group array elements based on keys produced by a discriminator
@@ -228,7 +231,7 @@ export function groupByAndMap(iterable, discriminator, mapper) {
  * @returns {NodeJS.Global.Map<R, Array<T>>}
  */
 export function groupBy(iterable, discriminator) {
-	return groupByAndMap(iterable, discriminator, identity)
+    return groupByAndMap(iterable, discriminator, identity);
 }
 /**
  * split an array into chunks of a given size.
@@ -238,22 +241,22 @@ export function groupBy(iterable, discriminator) {
  * @returns {Array<Array<T>>}
  */
 export function splitInChunks(chunkSize, array) {
-	if (chunkSize < 1) {
-		return []
-	}
-	let chunkNum = 0
-	const chunks = []
-	let end
-	do {
-		let start = chunkNum * chunkSize
-		end = start + chunkSize
-		chunks[chunkNum] = array.slice(start, end)
-		chunkNum++
-	} while (end < array.length)
-	return chunks
+    if (chunkSize < 1) {
+        return [];
+    }
+    let chunkNum = 0;
+    const chunks = [];
+    let end;
+    do {
+        let start = chunkNum * chunkSize;
+        end = start + chunkSize;
+        chunks[chunkNum] = array.slice(start, end);
+        chunkNum++;
+    } while (end < array.length);
+    return chunks;
 }
 export function flat(arrays) {
-	return arrays.flat()
+    return arrays.flat();
 }
 /**
  * Maps an array into a nested array and then flattens it
@@ -262,12 +265,12 @@ export function flat(arrays) {
  * @returns {T|*[]}
  */
 export function flatMap(array, mapper) {
-	const result = []
-	for (const item of array) {
-		const mapped = mapper(item)
-		result.push(...mapped)
-	}
-	return result
+    const result = [];
+    for (const item of array) {
+        const mapped = mapper(item);
+        result.push(...mapped);
+    }
+    return result;
 }
 /**
  * Inserts element into the sorted array. Will find <b>the last</b> matching position.
@@ -279,39 +282,41 @@ export function flatMap(array, mapper) {
  * @param replaceIf identity comparison for replacement
  */
 export function insertIntoSortedArray(element, array, comparator, replaceIf = () => false) {
-	let i = 0
-	while (i < array.length) {
-		const compareResult = comparator(array[i], element)
-		// We need to check for replacement for each element that is equal or we might miss it
-		if (compareResult === 0 && replaceIf(element, array[i])) {
-			array.splice(i, 1, element)
-			return
-		} else if (compareResult <= 0) {
-			// We continue searching until the last suitable position
-			i++
-		} else {
-			break
-		}
-	}
-	// This also handles empty array
-	array.splice(i, 0, element)
+    let i = 0;
+    while (i < array.length) {
+        const compareResult = comparator(array[i], element);
+        // We need to check for replacement for each element that is equal or we might miss it
+        if (compareResult === 0 && replaceIf(element, array[i])) {
+            array.splice(i, 1, element);
+            return;
+        }
+        else if (compareResult <= 0) {
+            // We continue searching until the last suitable position
+            i++;
+        }
+        else {
+            break;
+        }
+    }
+    // This also handles empty array
+    array.splice(i, 0, element);
 }
 export function zip(arr1, arr2) {
-	const zipped = []
-	for (let i = 0; i < Math.min(arr1.length, arr2.length); i++) {
-		zipped.push([arr1[i], arr2[i]])
-	}
-	return zipped
+    const zipped = [];
+    for (let i = 0; i < Math.min(arr1.length, arr2.length); i++) {
+        zipped.push([arr1[i], arr2[i]]);
+    }
+    return zipped;
 }
 export function deduplicate(arr, comp = (a, b) => a === b) {
-	const deduplicated = []
-	arr.forEach(a => {
-		const isDuplicate = deduplicated.some(b => comp(a, b))
-		if (!isDuplicate) {
-			deduplicated.push(a)
-		}
-	})
-	return deduplicated
+    const deduplicated = [];
+    arr.forEach(a => {
+        const isDuplicate = deduplicated.some(b => comp(a, b));
+        if (!isDuplicate) {
+            deduplicated.push(a);
+        }
+    });
+    return deduplicated;
 }
 /**
  * http://jsfiddle.net/aryzhov/pkfst550/
@@ -328,33 +333,36 @@ export function deduplicate(arr, comp = (a, b) => a === b) {
  * the returned value can be the index of any one of the equal elements.
  */
 export function binarySearch(ar, el, compare_fn) {
-	var m = 0
-	var n = ar.length - 1
-	while (m <= n) {
-		var k = (n + m) >> 1
-		var cmp = compare_fn(el, ar[k])
-		if (cmp > 0) {
-			m = k + 1
-		} else if (cmp < 0) {
-			n = k - 1
-		} else {
-			return k
-		}
-	}
-	return -m - 1
+    var m = 0;
+    var n = ar.length - 1;
+    while (m <= n) {
+        var k = (n + m) >> 1;
+        var cmp = compare_fn(el, ar[k]);
+        if (cmp > 0) {
+            m = k + 1;
+        }
+        else if (cmp < 0) {
+            n = k - 1;
+        }
+        else {
+            return k;
+        }
+    }
+    return -m - 1;
 }
 export function lastIndex(array) {
-	if (array.length === 0) {
-		return 0
-	} else {
-		return array.length - 1
-	}
+    if (array.length === 0) {
+        return 0;
+    }
+    else {
+        return array.length - 1;
+    }
 }
 /**
  * All of the elements in all of the arguments combined, and deduplicated
  */
 export function union(...iterables) {
-	return new Set(...iterables.map(iterable => Array.from(iterable)))
+    return new Set(...iterables.map(iterable => Array.from(iterable)));
 }
 /**
  * return a new array containing every item from array1 that isn't in array2
@@ -364,7 +372,7 @@ export function union(...iterables) {
  * @returns {Array<$NonMaybeType<T>>|Array<T>}
  */
 export function difference(array1, array2, compare = (a, b) => a === b) {
-	return array1.filter(element1 => !array2.some(element2 => compare(element1, element2)))
+    return array1.filter(element1 => !array2.some(element2 => compare(element1, element2)));
 }
 /**
  * Returns a set with elements that are *not* in both sets.
@@ -372,18 +380,18 @@ export function difference(array1, array2, compare = (a, b) => a === b) {
  * {a, b, c} △ {b, c, d} == {a, d}
  */
 export function symmetricDifference(set1, set2) {
-	const diff = new Set()
-	for (const el of set1) {
-		if (!set2.has(el)) {
-			diff.add(el)
-		}
-	}
-	for (const el of set2) {
-		if (!set1.has(el)) {
-			diff.add(el)
-		}
-	}
-	return diff
+    const diff = new Set();
+    for (const el of set1) {
+        if (!set2.has(el)) {
+            diff.add(el);
+        }
+    }
+    for (const el of set2) {
+        if (!set1.has(el)) {
+            diff.add(el);
+        }
+    }
+    return diff;
 }
 /**
  * Splits an array into two based on a predicate, where elements that match the predicate go into the left side
@@ -391,16 +399,17 @@ export function symmetricDifference(set1, set2) {
  * @param predicate
  */
 export function partition(array, predicate) {
-	const left = []
-	const right = []
-	for (let item of array) {
-		if (predicate(item)) {
-			left.push(item)
-		} else {
-			right.push(item)
-		}
-	}
-	return [left, right]
+    const left = [];
+    const right = [];
+    for (let item of array) {
+        if (predicate(item)) {
+            left.push(item);
+        }
+        else {
+            right.push(item);
+        }
+    }
+    return [left, right];
 }
 /**
  * like partition(), but async
@@ -409,13 +418,13 @@ export function partition(array, predicate) {
  * @param predicate
  */
 export async function partitionAsync(array, predicate) {
-	const mask = await Promise.all(array.map(predicate))
-	const [left, right] = partition(zip(mask, array), item => item[0])
-	return [left.map(i => i[1]), right.map(i => i[1])]
+    const mask = await Promise.all(array.map(predicate));
+    const [left, right] = partition(zip(mask, array), item => item[0]);
+    return [left.map(i => i[1]), right.map(i => i[1])];
 }
 /**
  * Create an array with n elements by calling the provided factory
  */
 export function arrayOf(n, factory) {
-	return numberRange(0, n - 1).map(factory)
+    return numberRange(0, n - 1).map(factory);
 }

package/dist/AsyncResult.d.ts

@@ -1,25 +1,23 @@
 declare type StatePending<T> = {
-	status: "pending"
-}
+    status: "pending";
+    promise: Promise<T>;
+};
 declare type StateComplete<T> = {
-	status: "complete"
-	result: T
-}
+    status: "complete";
+    result: T;
+};
 declare type StateFailure = {
-	status: "failure"
-	error: any
-}
-declare type AsyncResultState<T> = StatePending<T> | StateComplete<T> | StateFailure
-declare type PromiseCallback<T> = (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void
+    status: "failure";
+    error: any;
+};
+declare type AsyncResultState<T> = StatePending<T> | StateComplete<T> | StateFailure;
 /**
  * Represents a resource that is either not ready, ready, or error
  * Sort of fills a similar role to LazyLoaded, usage is more verbose but also more typesafe. maybe this should be reconciled.
  */
-export declare class AsyncResult<T> extends Promise<T> {
-	private _state
-	constructor(promiseOrCallback: PromiseCallback<T> | Promise<T>)
-	state(): Readonly<AsyncResultState<T>>
-	result(): T | null
-	static completed<T>(value: T): AsyncResult<T>
+export declare class AsyncResult<T> {
+    _state: AsyncResultState<T>;
+    constructor(promise: Promise<T>);
+    state(): Readonly<AsyncResultState<T>>;
 }
-export {}
+export {};