@tutao/tutanota-utils 3.94.0 → 3.94.1

package/dist/LazyLoaded.js

@@ -1,71 +1,72 @@
-import { neverNull } from "./Utils.js"
+import { neverNull } from "./Utils.js";
 /**
  * A wrapper for an object that shall be lazy loaded asynchronously. If loading the object is triggered in parallel (getAsync()) the object is actually only loaded once but returned to all calls of getAsync().
  * If the object was loaded once it is not loaded again.
  */
 export class LazyLoaded {
-	/**
-	 * @param loadFunction The function that actually loads the object as soon as getAsync() is called the first time.
-	 * @param defaultValue The value that shall be returned by getSync() or getLoaded() as long as the object is not loaded yet.
-	 */
-	constructor(loadFunction, defaultValue) {
-		this._isLoaded = false
-		this._loadFunction = loadFunction
-		this._loadingPromise = null
-		this._loadedObject = defaultValue !== null && defaultValue !== void 0 ? defaultValue : null
-	}
-	load() {
-		this.getAsync()
-		return this
-	}
-	isLoaded() {
-		return this._isLoaded
-	}
-	/**
-	 * Loads the object if it is not loaded yet. May be called in parallel and takes care that the load function is only called once.
-	 */
-	getAsync() {
-		if (this.isLoaded()) {
-			return Promise.resolve(neverNull(this._loadedObject))
-		} else {
-			if (!this._loadingPromise) {
-				this._loadingPromise = this._loadFunction().then(result => {
-					this._loadedObject = result
-					this._isLoaded = true
-					return result
-				})
-			}
-			return this._loadingPromise
-		}
-	}
-	/**
-	 * Returns null if the object is not loaded yet.
-	 */
-	getSync() {
-		return this._loadedObject
-	}
-	/**
-	 * Only call this function if you know that the object is already loaded.
-	 */
-	getLoaded() {
-		return neverNull(this._loadedObject)
-	}
-	/**
-	 * Removes the currently loaded object, so it will be loaded again with the next getAsync() call. Does not set any default value.
-	 */
-	reset() {
-		this._isLoaded = false
-		this._loadingPromise = null
-		this._loadedObject = null
-	}
-	/**
-	 * Loads the object again and replaces the current one
-	 */
-	reload() {
-		return this._loadFunction().then(result => {
-			this._isLoaded = true
-			this._loadedObject = result
-			return result
-		})
-	}
+    /**
+     * @param loadFunction The function that actually loads the object as soon as getAsync() is called the first time.
+     * @param defaultValue The value that shall be returned by getSync() or getLoaded() as long as the object is not loaded yet.
+     */
+    constructor(loadFunction, defaultValue) {
+        this._isLoaded = false;
+        this._loadFunction = loadFunction;
+        this._loadingPromise = null;
+        this._loadedObject = defaultValue !== null && defaultValue !== void 0 ? defaultValue : null;
+    }
+    load() {
+        this.getAsync();
+        return this;
+    }
+    isLoaded() {
+        return this._isLoaded;
+    }
+    /**
+     * Loads the object if it is not loaded yet. May be called in parallel and takes care that the load function is only called once.
+     */
+    getAsync() {
+        if (this.isLoaded()) {
+            return Promise.resolve(neverNull(this._loadedObject));
+        }
+        else {
+            if (!this._loadingPromise) {
+                this._loadingPromise = this._loadFunction().then(result => {
+                    this._loadedObject = result;
+                    this._isLoaded = true;
+                    return result;
+                });
+            }
+            return this._loadingPromise;
+        }
+    }
+    /**
+     * Returns null if the object is not loaded yet.
+     */
+    getSync() {
+        return this._loadedObject;
+    }
+    /**
+     * Only call this function if you know that the object is already loaded.
+     */
+    getLoaded() {
+        return neverNull(this._loadedObject);
+    }
+    /**
+     * Removes the currently loaded object, so it will be loaded again with the next getAsync() call. Does not set any default value.
+     */
+    reset() {
+        this._isLoaded = false;
+        this._loadingPromise = null;
+        this._loadedObject = null;
+    }
+    /**
+     * Loads the object again and replaces the current one
+     */
+    reload() {
+        return this._loadFunction().then(result => {
+            this._isLoaded = true;
+            this._loadedObject = result;
+            return result;
+        });
+    }
 }

package/dist/MapUtils.d.ts

@@ -2,8 +2,8 @@
  * Merges multiple maps into a single map with lists of values.
  * @param maps
  */
-export declare function mergeMaps<T>(maps: Map<string, T>[]): Map<string, T[]>
-export declare function getFromMap<K, V>(map: Map<K, V>, key: K, byDefault: () => V): V
+export declare function mergeMaps<T>(maps: Map<string, T>[]): Map<string, T[]>;
+export declare function getFromMap<K, V>(map: Map<K, V>, key: K, byDefault: () => V): V;
 /** Creates a new map with key and value added to {@param map}. It is like set() but for immutable map. */
-export declare function addMapEntry<K, V>(map: ReadonlyMap<K, V>, key: K, value: V): Map<K, V>
-export declare function deleteMapEntry<K, V>(map: ReadonlyMap<K, V>, key: K): Map<K, V>
+export declare function addMapEntry<K, V>(map: ReadonlyMap<K, V>, key: K, value: V): Map<K, V>;
+export declare function deleteMapEntry<K, V>(map: ReadonlyMap<K, V>, key: K): Map<K, V>;

package/dist/MapUtils.js

@@ -1,37 +1,38 @@
-import { neverNull } from "./Utils.js"
+import { neverNull } from "./Utils.js";
 /**
  * Merges multiple maps into a single map with lists of values.
  * @param maps
  */
 export function mergeMaps(maps) {
-	return maps.reduce((mergedMap, map) => {
-		// merge same key of multiple attributes
-		map.forEach((value, key) => {
-			if (mergedMap.has(key)) {
-				neverNull(mergedMap.get(key)).push(value)
-			} else {
-				mergedMap.set(key, [value])
-			}
-		})
-		return mergedMap
-	}, new Map())
+    return maps.reduce((mergedMap, map) => {
+        // merge same key of multiple attributes
+        map.forEach((value, key) => {
+            if (mergedMap.has(key)) {
+                neverNull(mergedMap.get(key)).push(value);
+            }
+            else {
+                mergedMap.set(key, [value]);
+            }
+        });
+        return mergedMap;
+    }, new Map());
 }
 export function getFromMap(map, key, byDefault) {
-	let value = map.get(key)
-	if (!value) {
-		value = byDefault()
-		map.set(key, value)
-	}
-	return value
+    let value = map.get(key);
+    if (!value) {
+        value = byDefault();
+        map.set(key, value);
+    }
+    return value;
 }
 /** Creates a new map with key and value added to {@param map}. It is like set() but for immutable map. */
 export function addMapEntry(map, key, value) {
-	const newMap = new Map(map)
-	newMap.set(key, value)
-	return newMap
+    const newMap = new Map(map);
+    newMap.set(key, value);
+    return newMap;
 }
 export function deleteMapEntry(map, key) {
-	const newMap = new Map(map)
-	newMap.delete(key)
-	return newMap
+    const newMap = new Map(map);
+    newMap.delete(key);
+    return newMap;
 }

package/dist/MathUtils.d.ts

@@ -1,5 +1,5 @@
-export declare function mod(n: number, m: number): number
+export declare function mod(n: number, m: number): number;
 /**
  * Clamp value to between min and max (inclusive)
  */
-export declare function clamp(value: number, min: number, max: number): number
+export declare function clamp(value: number, min: number, max: number): number;

package/dist/MathUtils.js

@@ -1,9 +1,9 @@
 export function mod(n, m) {
-	return ((n % m) + m) % m
+    return ((n % m) + m) % m;
 }
 /**
  * Clamp value to between min and max (inclusive)
  */
 export function clamp(value, min, max) {
-	return Math.max(min, Math.min(value, max))
+    return Math.max(min, Math.min(value, max));
 }

package/dist/PromiseMap.d.ts

@@ -5,19 +5,19 @@
  * Changed: default concurrency level is 1 and not Infinite
  */
 export interface Options {
-	/**
+    /**
     Number of concurrently pending promises returned by `mapper`.
     Must be an integer from 1 and up or `Infinity`.
     @default 1
    */
-	readonly concurrency?: number
+    readonly concurrency?: number;
 }
 /**
     Function which is called for every item in `input`. Expected to return a `Promise` or value.
     @param element - Iterated element.
     @param index - Index of the element in the source array.
  */
-export declare type Mapper<Element, NewElement> = (element: Element, index: number) => Promise<NewElement> | NewElement
+export declare type Mapper<Element, NewElement> = (element: Element, index: number) => Promise<NewElement> | NewElement;
 /**
     @param iterable - Iterated over concurrently in the `mapper` function.
     @param mapper - Function which is called for every item in `input`. Expected to return a `Promise` or value.
@@ -41,8 +41,4 @@ export declare type Mapper<Element, NewElement> = (element: Element, index: numb
     //=> ['https://sindresorhus.com/', 'https://avajs.dev/', 'https://github.com/']
     ```
  */
-export declare function pMap<Element, NewElement>(
-	iterable: Iterable<Element>,
-	mapper: Mapper<Element, NewElement>,
-	options?: Options,
-): Promise<Array<NewElement>>
+export declare function pMap<Element, NewElement>(iterable: Iterable<Element>, mapper: Mapper<Element, NewElement>, options?: Options): Promise<Array<NewElement>>;

package/dist/PromiseMap.js

@@ -22,53 +22,54 @@
     ```
  */
 export async function pMap(iterable, mapper, options = {}) {
-	const { concurrency = 1 } = options
-	return new Promise((resolve, reject) => {
-		if (typeof mapper !== "function") {
-			throw new TypeError("Mapper function is required")
-		}
-		if (!((Number.isSafeInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency >= 1)) {
-			throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`)
-		}
-		const result = []
-		const errors = []
-		const iterator = iterable[Symbol.iterator]()
-		let isRejected = false
-		let isIterableDone = false
-		let resolvingCount = 0
-		let currentIndex = 0
-		const next = () => {
-			if (isRejected) {
-				return
-			}
-			const nextItem = iterator.next()
-			const index = currentIndex
-			currentIndex++
-			if (nextItem.done) {
-				isIterableDone = true
-				if (resolvingCount === 0) {
-					resolve(result)
-				}
-				return
-			}
-			resolvingCount++
-			;(async () => {
-				try {
-					const element = await nextItem.value
-					result[index] = await mapper(element, index)
-					resolvingCount--
-					next()
-				} catch (error) {
-					isRejected = true
-					reject(error)
-				}
-			})()
-		}
-		for (let index = 0; index < concurrency; index++) {
-			next()
-			if (isIterableDone) {
-				break
-			}
-		}
-	})
+    const { concurrency = 1 } = options;
+    return new Promise((resolve, reject) => {
+        if (typeof mapper !== "function") {
+            throw new TypeError("Mapper function is required");
+        }
+        if (!((Number.isSafeInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency >= 1)) {
+            throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`);
+        }
+        const result = [];
+        const errors = [];
+        const iterator = iterable[Symbol.iterator]();
+        let isRejected = false;
+        let isIterableDone = false;
+        let resolvingCount = 0;
+        let currentIndex = 0;
+        const next = () => {
+            if (isRejected) {
+                return;
+            }
+            const nextItem = iterator.next();
+            const index = currentIndex;
+            currentIndex++;
+            if (nextItem.done) {
+                isIterableDone = true;
+                if (resolvingCount === 0) {
+                    resolve(result);
+                }
+                return;
+            }
+            resolvingCount++;
+            (async () => {
+                try {
+                    const element = await nextItem.value;
+                    result[index] = await mapper(element, index);
+                    resolvingCount--;
+                    next();
+                }
+                catch (error) {
+                    isRejected = true;
+                    reject(error);
+                }
+            })();
+        };
+        for (let index = 0; index < concurrency; index++) {
+            next();
+            if (isIterableDone) {
+                break;
+            }
+        }
+    });
 }

package/dist/PromiseUtils.d.ts

@@ -1,6 +1,6 @@
-import type { Options as PromiseMapOptions } from "./PromiseMap.js"
-export declare type $Promisable<T> = Promise<T> | T
-declare type PromiseMapCallback<T, U> = (el: T, index: number) => $Promisable<U>
+import type { Options as PromiseMapOptions } from "./PromiseMap.js";
+export declare type $Promisable<T> = Promise<T> | T;
+declare type PromiseMapCallback<T, U> = (el: T, index: number) => $Promisable<U>;
 /**
  * Map array of values to promise of arrays or array. Mapper function may return promise or value. If value is returned,
  * we avoid promise scheduling.
@@ -8,27 +8,24 @@ declare type PromiseMapCallback<T, U> = (el: T, index: number) => $Promisable<U>
  * This is needed to run the whole operation in one microtask (e.g. keep IndexedDB transaction active, which is closed in
  * some browsers (e.g. Safari) when event loop iteration ends).
  */
-export declare function mapInCallContext<T, U>(values: T[], callback: PromiseMapCallback<T, U>): PromisableWrapper<Array<U>>
-export { pMap as promiseMap } from "./PromiseMap.js"
-export declare type PromiseMapFn = <T, U>(values: T[], callback: PromiseMapCallback<T, U>, options?: PromiseMapOptions) => PromisableWrapper<U[]>
+export declare function mapInCallContext<T, U>(values: T[], callback: PromiseMapCallback<T, U>): PromisableWrapper<Array<U>>;
+export { pMap as promiseMap } from "./PromiseMap.js";
+export declare type PromiseMapFn = <T, U>(values: T[], callback: PromiseMapCallback<T, U>, options?: PromiseMapOptions) => PromisableWrapper<U[]>;
 /** Factory function which gives you ack promiseMap implementation. {@see mapInCallContext} for what it means. */
-export declare function promiseMapCompat(useMapInCallContext: boolean): PromiseMapFn
+export declare function promiseMapCompat(useMapInCallContext: boolean): PromiseMapFn;
 export declare class PromisableWrapper<T> {
-	static from<U>(value: $Promisable<U>): PromisableWrapper<U>
-	value: $Promisable<T>
-	constructor(value: $Promisable<PromisableWrapper<T> | T>)
-	thenOrApply<R>(
-		onFulfill: (arg0: T) => $Promisable<PromisableWrapper<R> | R>,
-		onReject?: (arg0: any) => $Promisable<R | PromisableWrapper<R>>,
-	): PromisableWrapper<R>
-	toPromise(): Promise<T>
+    static from<U>(value: $Promisable<U>): PromisableWrapper<U>;
+    value: $Promisable<T>;
+    constructor(value: $Promisable<PromisableWrapper<T> | T>);
+    thenOrApply<R>(onFulfill: (arg0: T) => $Promisable<PromisableWrapper<R> | R>, onReject?: (arg0: any) => $Promisable<R | PromisableWrapper<R>>): PromisableWrapper<R>;
+    toPromise(): Promise<T>;
 }
-export declare function delay(ms: number): Promise<void>
+export declare function delay(ms: number): Promise<void>;
 /**
  * Pass to Promise.then to perform an action while forwarding on the result
  * @param action
  */
-export declare function tap<T>(action: (arg0: T) => unknown): (arg0: T) => T
+export declare function tap<T>(action: (arg0: T) => unknown): (arg0: T) => T;
 /**
  * Helper utility intended to be used with typed exceptions and .catch() method of promise like so:
  *
@@ -44,8 +41,8 @@ export declare function tap<T>(action: (arg0: T) => unknown): (arg0: T) => T
  * @param catcher to handle only errors of type cls
  * @returns handler which either forwards to catcher or rethrows
  */
-export declare function ofClass<E, R>(cls: Class<E>, catcher: (arg0: E) => $Promisable<R>): (arg0: any) => Promise<R>
+export declare function ofClass<E, R>(cls: Class<E>, catcher: (arg0: E) => $Promisable<R>): (arg0: any) => Promise<R>;
 /**
  * Filter iterable. Just like Array.prototype.filter but callback can return promises
  */
-export declare function promiseFilter<T>(iterable: Iterable<T>, filter: (item: T, index: number) => $Promisable<boolean>): Promise<Array<T>>
+export declare function promiseFilter<T>(iterable: Iterable<T>, filter: (item: T, index: number) => $Promisable<boolean>): Promise<Array<T>>;

package/dist/PromiseUtils.js

@@ -1,4 +1,4 @@
-import { pMap as promiseMap } from "./PromiseMap.js"
+import { pMap as promiseMap } from "./PromiseMap.js";
 /**
  * Map array of values to promise of arrays or array. Mapper function may return promise or value. If value is returned,
  * we avoid promise scheduling.
@@ -7,78 +7,81 @@ import { pMap as promiseMap } from "./PromiseMap.js"
  * some browsers (e.g. Safari) when event loop iteration ends).
  */
 export function mapInCallContext(values, callback) {
-	return new PromisableWrapper(_mapInCallContext(values, callback, 0, []))
+    return new PromisableWrapper(_mapInCallContext(values, callback, 0, []));
 }
 function _mapInCallContext(values, callback, index, acc) {
-	if (index >= values.length) {
-		return acc
-	}
-	let mappedValue = callback(values[index], index)
-	if (mappedValue instanceof Promise) {
-		return mappedValue.then(v => {
-			acc.push(v)
-			return _mapInCallContext(values, callback, index + 1, acc)
-		})
-	} else {
-		acc.push(mappedValue)
-		return _mapInCallContext(values, callback, index + 1, acc)
-	}
+    if (index >= values.length) {
+        return acc;
+    }
+    let mappedValue = callback(values[index], index);
+    if (mappedValue instanceof Promise) {
+        return mappedValue.then(v => {
+            acc.push(v);
+            return _mapInCallContext(values, callback, index + 1, acc);
+        });
+    }
+    else {
+        acc.push(mappedValue);
+        return _mapInCallContext(values, callback, index + 1, acc);
+    }
 }
-export { pMap as promiseMap } from "./PromiseMap.js"
+export { pMap as promiseMap } from "./PromiseMap.js";
 function mapNoFallback(values, callback, options) {
-	return PromisableWrapper.from(promiseMap(values, callback, options))
+    return PromisableWrapper.from(promiseMap(values, callback, options));
 }
 /** Factory function which gives you ack promiseMap implementation. {@see mapInCallContext} for what it means. */
 export function promiseMapCompat(useMapInCallContext) {
-	return useMapInCallContext ? mapInCallContext : mapNoFallback
+    return useMapInCallContext ? mapInCallContext : mapNoFallback;
 }
 function flatWrapper(value) {
-	return value instanceof PromisableWrapper ? value.value : value
+    return value instanceof PromisableWrapper ? value.value : value;
 }
 // It kinda implements 'thenable' protocol so you can freely pass it around as a generic promise
 export class PromisableWrapper {
-	constructor(value) {
-		this.value = value instanceof Promise ? value.then(flatWrapper) : flatWrapper(value)
-	}
-	static from(value) {
-		return new PromisableWrapper(value)
-	}
-	thenOrApply(onFulfill, onReject) {
-		if (this.value instanceof Promise) {
-			const v = this.value.then(onFulfill, onReject)
-			return new PromisableWrapper(v)
-		} else {
-			try {
-				return new PromisableWrapper(onFulfill(this.value))
-			} catch (e) {
-				if (onReject) {
-					return new PromisableWrapper(onReject(e))
-				}
-				throw e
-			}
-		}
-	}
-	toPromise() {
-		return Promise.resolve(this.value)
-	}
+    constructor(value) {
+        this.value = value instanceof Promise ? value.then(flatWrapper) : flatWrapper(value);
+    }
+    static from(value) {
+        return new PromisableWrapper(value);
+    }
+    thenOrApply(onFulfill, onReject) {
+        if (this.value instanceof Promise) {
+            const v = this.value.then(onFulfill, onReject);
+            return new PromisableWrapper(v);
+        }
+        else {
+            try {
+                return new PromisableWrapper(onFulfill(this.value));
+            }
+            catch (e) {
+                if (onReject) {
+                    return new PromisableWrapper(onReject(e));
+                }
+                throw e;
+            }
+        }
+    }
+    toPromise() {
+        return Promise.resolve(this.value);
+    }
 }
 export function delay(ms) {
-	if (Number.isNaN(ms) || ms < 0) {
-		throw new Error(`Invalid delay: ${ms}`)
-	}
-	return new Promise(resolve => {
-		setTimeout(resolve, ms)
-	})
+    if (Number.isNaN(ms) || ms < 0) {
+        throw new Error(`Invalid delay: ${ms}`);
+    }
+    return new Promise(resolve => {
+        setTimeout(resolve, ms);
+    });
 }
 /**
  * Pass to Promise.then to perform an action while forwarding on the result
  * @param action
  */
 export function tap(action) {
-	return function (value) {
-		action(value)
-		return value
-	}
+    return function (value) {
+        action(value);
+        return value;
+    };
 }
 /**
  * Helper utility intended to be used with typed exceptions and .catch() method of promise like so:
@@ -96,28 +99,29 @@ export function tap(action) {
  * @returns handler which either forwards to catcher or rethrows
  */
 export function ofClass(cls, catcher) {
-	return async e => {
-		if (e instanceof cls) {
-			return catcher(e)
-		} else {
-			// It's okay to rethrow because:
-			// 1. It preserves the original stacktrace
-			// 2. Because of 1. it is not that expensive
-			throw e
-		}
-	}
+    return async (e) => {
+        if (e instanceof cls) {
+            return catcher(e);
+        }
+        else {
+            // It's okay to rethrow because:
+            // 1. It preserves the original stacktrace
+            // 2. Because of 1. it is not that expensive
+            throw e;
+        }
+    };
 }
 /**
  * Filter iterable. Just like Array.prototype.filter but callback can return promises
  */
 export async function promiseFilter(iterable, filter) {
-	let index = 0
-	const result = []
-	for (let item of iterable) {
-		if (await filter(item, index)) {
-			result.push(item)
-		}
-		index++
-	}
-	return result
+    let index = 0;
+    const result = [];
+    for (let item of iterable) {
+        if (await filter(item, index)) {
+            result.push(item);
+        }
+        index++;
+    }
+    return result;
 }