@tutao/tutanota-utils 3.93.7 → 3.94.0

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,26 +72,25 @@ 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
@@ -99,50 +98,48 @@ 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.
@@ -150,62 +147,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
@@ -217,12 +214,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
@@ -231,7 +228,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.
@@ -241,22 +238,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
@@ -265,12 +262,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.
@@ -282,41 +279,39 @@ 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/
@@ -333,36 +328,33 @@ 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
@@ -372,7 +364,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.
@@ -380,18 +372,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
@@ -399,17 +391,16 @@ 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
@@ -418,13 +409,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,23 +1,25 @@
 declare type StatePending<T> = {
-    status: "pending";
-    promise: Promise<T>;
-};
+	status: "pending"
+}
 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;
+	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
 /**
  * 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> {
-    _state: AsyncResultState<T>;
-    constructor(promise: Promise<T>);
-    state(): Readonly<AsyncResultState<T>>;
+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 {};
+export {}