@tutao/tutanota-utils 3.94.0 → 3.94.1

package/dist/SortedArray.d.ts

@@ -1,16 +1,16 @@
-export declare type CompareFn<T> = (arg0: T, arg1: T) => number
+export declare type CompareFn<T> = (arg0: T, arg1: T) => number;
 /**
  * An array that keeps itself sorted
  */
 export declare class SortedArray<T> {
-	readonly _contents: Array<T>
-	readonly _compareFn: CompareFn<T>
-	constructor(compareFn?: CompareFn<T>)
-	static from<U>(array: ReadonlyArray<U>, compareFn?: CompareFn<U>): SortedArray<U>
-	get length(): number
-	get array(): ReadonlyArray<T>
-	get(index: number): T
-	insertAll(array: ReadonlyArray<T>): void
-	insert(item: T): void
-	removeFirst(finder: (arg0: T) => boolean): boolean
+    readonly _contents: Array<T>;
+    readonly _compareFn: CompareFn<T>;
+    constructor(compareFn?: CompareFn<T>);
+    static from<U>(array: ReadonlyArray<U>, compareFn?: CompareFn<U>): SortedArray<U>;
+    get length(): number;
+    get array(): ReadonlyArray<T>;
+    get(index: number): T;
+    insertAll(array: ReadonlyArray<T>): void;
+    insert(item: T): void;
+    removeFirst(finder: (arg0: T) => boolean): boolean;
 }

package/dist/SortedArray.js

@@ -1,4 +1,4 @@
-import { findAndRemove, insertIntoSortedArray } from "./ArrayUtils.js"
+import { findAndRemove, insertIntoSortedArray } from "./ArrayUtils.js";
 /**
  * Compared based on the type's natural ordering
  * @param a
@@ -7,38 +7,38 @@ import { findAndRemove, insertIntoSortedArray } from "./ArrayUtils.js"
  */
 // It should be fine for 99% of use cases? worst case it just returns 0 always
 function defaultCompare(a, b) {
-	return a < b ? -1 : a > b ? 1 : 0
+    return a < b ? -1 : a > b ? 1 : 0;
 }
 /**
  * An array that keeps itself sorted
  */
 export class SortedArray {
-	constructor(compareFn = defaultCompare) {
-		this._contents = []
-		this._compareFn = compareFn
-	}
-	static from(array, compareFn) {
-		const list = new SortedArray(compareFn)
-		list.insertAll(array)
-		return list
-	}
-	get length() {
-		return this._contents.length
-	}
-	get array() {
-		return this._contents
-	}
-	get(index) {
-		return this._contents[index]
-	}
-	insertAll(array) {
-		this._contents.push(...array)
-		this._contents.sort(this._compareFn)
-	}
-	insert(item) {
-		insertIntoSortedArray(item, this._contents, this._compareFn)
-	}
-	removeFirst(finder) {
-		return findAndRemove(this._contents, finder)
-	}
+    constructor(compareFn = defaultCompare) {
+        this._contents = [];
+        this._compareFn = compareFn;
+    }
+    static from(array, compareFn) {
+        const list = new SortedArray(compareFn);
+        list.insertAll(array);
+        return list;
+    }
+    get length() {
+        return this._contents.length;
+    }
+    get array() {
+        return this._contents;
+    }
+    get(index) {
+        return this._contents[index];
+    }
+    insertAll(array) {
+        this._contents.push(...array);
+        this._contents.sort(this._compareFn);
+    }
+    insert(item) {
+        insertIntoSortedArray(item, this._contents, this._compareFn);
+    }
+    removeFirst(finder) {
+        return findAndRemove(this._contents, finder);
+    }
 }

package/dist/StringUtils.d.ts

@@ -1,58 +1,58 @@
-import type { lazy } from "./Utils.js"
+import type { lazy } from "./Utils.js";
 /**
  * Returns a string which contains the given number padded with 0s.
  * @param num The number to pad.
  * @param size The number of resulting digits.
  * @return The padded number as string.
  */
-export declare function pad(num: number, size: number): string
+export declare function pad(num: number, size: number): string;
 /**
  * Checks if a string starts with another string.
  * @param string The string to test.
  * @param substring If the other string begins with this one, we return true.
  * @return True if string begins with substring, false otherwise.
  */
-export declare function startsWith(string: string, substring: string): boolean
+export declare function startsWith(string: string, substring: string): boolean;
 /**
  * uppercase the first letter of a string, lowercase the rest
  * @param str string to transform
  * @returns {string} str in lowercase with first letter Capitalized
  */
-export declare function capitalizeFirstLetter(str: string): string
+export declare function capitalizeFirstLetter(str: string): string;
 /**
  * Checks if a string ends with another string.
  * @param string The string to test.
  * @param substring If the other string ends with this one, we return true.
  * @return True if string ends with substring, false otherwise.
  */
-export declare function endsWith(string: string, substring: string): boolean
-export declare function lazyStringValue(valueOrLazy: string | lazy<string>): string
-export declare function repeat(value: string, length: number): string
-export declare function cleanMatch(s1: string, s2: string): boolean
+export declare function endsWith(string: string, substring: string): boolean;
+export declare function lazyStringValue(valueOrLazy: string | lazy<string>): string;
+export declare function repeat(value: string, length: number): string;
+export declare function cleanMatch(s1: string, s2: string): boolean;
 /**
  * Non-breaking space character
  */
-export declare const NBSP = "\u00A0"
+export declare const NBSP = "\u00A0";
 /**
  * split a string at a given index
  * @param str
  * @param index
  */
-export declare function splitAt(str: string, index: number): [string, string]
+export declare function splitAt(str: string, index: number): [string, string];
 /**
  * Wrapper around String.prototype.toLowerCase, nice for calls to Array.prototype.map
  * @param str
  */
-export declare function toLowerCase(str: string): string
+export declare function toLowerCase(str: string): string;
 /**
  * Wrapper around String.prototype.localeCompare, for passing to Array.prototype.sort
  * @param a
  * @param b
  * @returns {number}
  */
-export declare function localeCompare(a: string, b: string): number
-export declare function byteLength(str: string | null | undefined): number
+export declare function localeCompare(a: string, b: string): number;
+export declare function byteLength(str: string | null | undefined): number;
 /**
  * replace all instances of substr in str with replacement
  */
-export declare function replaceAll(str: string, substr: string, replacement: string): string
+export declare function replaceAll(str: string, substr: string, replacement: string): string;

package/dist/StringUtils.js

@@ -5,9 +5,10 @@
  * @return The padded number as string.
  */
 export function pad(num, size) {
-	var s = num + ""
-	while (s.length < size) s = "0" + s
-	return s
+    var s = num + "";
+    while (s.length < size)
+        s = "0" + s;
+    return s;
 }
 /**
  * Checks if a string starts with another string.
@@ -16,7 +17,7 @@ export function pad(num, size) {
  * @return True if string begins with substring, false otherwise.
  */
 export function startsWith(string, substring) {
-	return string.startsWith(substring)
+    return string.startsWith(substring);
 }
 /**
  * uppercase the first letter of a string, lowercase the rest
@@ -24,7 +25,7 @@ export function startsWith(string, substring) {
  * @returns {string} str in lowercase with first letter Capitalized
  */
 export function capitalizeFirstLetter(str) {
-	return str[0].toUpperCase() + str.toLowerCase().slice(1)
+    return str[0].toUpperCase() + str.toLowerCase().slice(1);
 }
 /**
  * Checks if a string ends with another string.
@@ -33,39 +34,39 @@ export function capitalizeFirstLetter(str) {
  * @return True if string ends with substring, false otherwise.
  */
 export function endsWith(string, substring) {
-	return string.endsWith(substring)
+    return string.endsWith(substring);
 }
 export function lazyStringValue(valueOrLazy) {
-	return typeof valueOrLazy === "function" ? valueOrLazy() : valueOrLazy
+    return typeof valueOrLazy === "function" ? valueOrLazy() : valueOrLazy;
 }
 export function repeat(value, length) {
-	let result = ""
-	for (let i = 0; i < length; i++) {
-		result += value
-	}
-	return result
+    let result = "";
+    for (let i = 0; i < length; i++) {
+        result += value;
+    }
+    return result;
 }
 export function cleanMatch(s1, s2) {
-	return s1.toLowerCase().trim() === s2.toLowerCase().trim()
+    return s1.toLowerCase().trim() === s2.toLowerCase().trim();
 }
 /**
  * Non-breaking space character
  */
-export const NBSP = "\u00A0"
+export const NBSP = "\u00A0";
 /**
  * split a string at a given index
  * @param str
  * @param index
  */
 export function splitAt(str, index) {
-	return [str.substring(0, index), str.substring(index)]
+    return [str.substring(0, index), str.substring(index)];
 }
 /**
  * Wrapper around String.prototype.toLowerCase, nice for calls to Array.prototype.map
  * @param str
  */
 export function toLowerCase(str) {
-	return str.toLowerCase()
+    return str.toLowerCase();
 }
 /**
  * Wrapper around String.prototype.localeCompare, for passing to Array.prototype.sort
@@ -74,32 +75,36 @@ export function toLowerCase(str) {
  * @returns {number}
  */
 export function localeCompare(a, b) {
-	return a.localeCompare(b)
+    return a.localeCompare(b);
 }
 export function byteLength(str) {
-	if (str == null) return 0
-	// returns the byte length of an utf8 string
-	var s = str.length
-	for (var i = str.length - 1; i >= 0; i--) {
-		var code = str.charCodeAt(i)
-		if (code > 0x7f && code <= 0x7ff) {
-			s++
-		} else if (code > 0x7ff && code <= 0xffff) s += 2
-		if (code >= 0xdc00 && code <= 0xdfff) i-- //trail surrogate
-	}
-	return s
+    if (str == null)
+        return 0;
+    // returns the byte length of an utf8 string
+    var s = str.length;
+    for (var i = str.length - 1; i >= 0; i--) {
+        var code = str.charCodeAt(i);
+        if (code > 0x7f && code <= 0x7ff) {
+            s++;
+        }
+        else if (code > 0x7ff && code <= 0xffff)
+            s += 2;
+        if (code >= 0xdc00 && code <= 0xdfff)
+            i--; //trail surrogate
+    }
+    return s;
 }
 /**
  * replace all instances of substr in str with replacement
  */
 export function replaceAll(str, substr, replacement) {
-	const regex = escapedStringRegExp(substr, "g")
-	return str.replace(regex, replacement)
+    const regex = escapedStringRegExp(substr, "g");
+    return str.replace(regex, replacement);
 }
 /**
  * Create a regex to exactly match a given string, by escaping any special regex characters
  * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#escaping
  * */
 function escapedStringRegExp(str, flags) {
-	return new RegExp(str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), flags)
+    return new RegExp(str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), flags);
 }

package/dist/TypeRef.d.ts

@@ -1,13 +1,13 @@
 export declare class TypeRef<T> {
-	readonly app: string
-	readonly type: string
-	/**
-	 * Field that is never set. Used to make two TypeRefs incompatible (they are structurally compared otherwise).
-	 * Cannot be private.
-	 */
-	readonly phantom: T | null
-	constructor(app: string, type: string)
-	toString(): string
+    readonly app: string;
+    readonly type: string;
+    /**
+     * Field that is never set. Used to make two TypeRefs incompatible (they are structurally compared otherwise).
+     * Cannot be private.
+     */
+    readonly phantom: T | null;
+    constructor(app: string, type: string);
+    toString(): string;
 }
-export declare function isSameTypeRefByAttr(typeRef: TypeRef<any>, app: string, type: string): boolean
-export declare function isSameTypeRef(typeRef1: TypeRef<any>, typeRef2: TypeRef<any>): boolean
+export declare function isSameTypeRefByAttr(typeRef: TypeRef<any>, app: string, type: string): boolean;
+export declare function isSameTypeRef(typeRef1: TypeRef<any>, typeRef2: TypeRef<any>): boolean;

package/dist/TypeRef.js

@@ -1,22 +1,22 @@
 // T should be restricted to Entity
 export class TypeRef {
-	constructor(app, type) {
-		/**
-		 * Field that is never set. Used to make two TypeRefs incompatible (they are structurally compared otherwise).
-		 * Cannot be private.
-		 */
-		this.phantom = null
-		this.app = app
-		this.type = type
-		Object.freeze(this)
-	}
-	toString() {
-		return `[TypeRef ${this.app} ${this.type}]`
-	}
+    constructor(app, type) {
+        /**
+         * Field that is never set. Used to make two TypeRefs incompatible (they are structurally compared otherwise).
+         * Cannot be private.
+         */
+        this.phantom = null;
+        this.app = app;
+        this.type = type;
+        Object.freeze(this);
+    }
+    toString() {
+        return `[TypeRef ${this.app} ${this.type}]`;
+    }
 }
 export function isSameTypeRefByAttr(typeRef, app, type) {
-	return typeRef.app === app && typeRef.type === type
+    return typeRef.app === app && typeRef.type === type;
 }
 export function isSameTypeRef(typeRef1, typeRef2) {
-	return isSameTypeRefByAttr(typeRef1, typeRef2.app, typeRef2.type)
+    return isSameTypeRefByAttr(typeRef1, typeRef2.app, typeRef2.type);
 }

package/dist/Utils.d.ts

@@ -1,63 +1,57 @@
-export declare type lazy<T> = () => T
-export declare type lazyAsync<T> = () => Promise<T>
-export declare type Thunk = () => unknown
+export declare type lazy<T> = () => T;
+export declare type lazyAsync<T> = () => Promise<T>;
+export declare type Thunk = () => unknown;
 export declare type DeferredObject<T> = {
-	resolve: (arg0: T) => void
-	reject: (arg0: Error) => void
-	promise: Promise<T>
-}
+    resolve: (arg0: T) => void;
+    reject: (arg0: Error) => void;
+    promise: Promise<T>;
+};
 export declare type DeferredObjectWithHandler<T, U> = {
-	resolve: (arg0: T) => void
-	reject: (arg0: Error) => void
-	promise: Promise<U>
-}
-export declare function defer<T>(): DeferredObject<T>
-export declare function deferWithHandler<T, U>(handler: (arg0: T) => U): DeferredObjectWithHandler<T, U>
-export declare function asyncFind<T>(
-	array: ReadonlyArray<T>,
-	finder: (item: T, index: number, arrayLength: number) => Promise<boolean>,
-): Promise<T | null | undefined>
-export declare function asyncFindAndMap<T, R>(
-	array: ReadonlyArray<T>,
-	finder: (item: T, index: number, arrayLength: number) => Promise<R | null>,
-): Promise<R | null | undefined>
+    resolve: (arg0: T) => void;
+    reject: (arg0: Error) => void;
+    promise: Promise<U>;
+};
+export declare function defer<T>(): DeferredObject<T>;
+export declare function deferWithHandler<T, U>(handler: (arg0: T) => U): DeferredObjectWithHandler<T, U>;
+export declare function asyncFind<T>(array: ReadonlyArray<T>, finder: (item: T, index: number, arrayLength: number) => Promise<boolean>): Promise<T | null | undefined>;
+export declare function asyncFindAndMap<T, R>(array: ReadonlyArray<T>, finder: (item: T, index: number, arrayLength: number) => Promise<R | null>): Promise<R | null | undefined>;
 /**
  * Calls an executor function for slices of nbrOfElementsInGroup items of the given array until the executor function returns false.
  */
-export declare function executeInGroups<T>(array: T[], nbrOfElementsInGroup: number, executor: (items: T[]) => Promise<boolean>): Promise<void>
-export declare function neverNull<T>(object: T): NonNullable<T>
-export declare function assertNotNull<T>(object: T | null | undefined, message?: string): T
-export declare function isNotNull<T>(t: T | null | undefined): t is T
-export declare function assert(assertion: MaybeLazy<boolean>, message: string): void
-export declare function downcast<R = any>(object: any): R
-export declare function clone<T>(instance: T): T
+export declare function executeInGroups<T>(array: T[], nbrOfElementsInGroup: number, executor: (items: T[]) => Promise<boolean>): Promise<void>;
+export declare function neverNull<T>(object: T): NonNullable<T>;
+export declare function assertNotNull<T>(object: T | null | undefined, message?: string): T;
+export declare function isNotNull<T>(t: T | null | undefined): t is T;
+export declare function assert(assertion: MaybeLazy<boolean>, message: string): void;
+export declare function downcast<R = any>(object: any): R;
+export declare function clone<T>(instance: T): T;
 /**
  * Function which accepts another function. On first invocation
  * of this resulting function result will be remembered and returned
  * on consequent invocations.
  */
-export declare function lazyMemoized<T>(source: () => T): () => T
+export declare function lazyMemoized<T>(source: () => T): () => T;
 /**
  * Returns a cached version of {@param fn}.
  * Cached function checks that argument is the same (with ===) and if it is then it returns the cached result.
  * If the cached argument has changed then {@param fn} will be called with new argument and result will be cached again.
  * Only remembers the last argument.
  */
-export declare function memoized<T, R>(fn: (arg0: T) => R): (arg0: T) => R
+export declare function memoized<T, R>(fn: (arg0: T) => R): (arg0: T) => R;
 /**
  * Function which returns what was passed into it
  */
-export declare function identity<T>(t: T): T
+export declare function identity<T>(t: T): T;
 /**
  * Function which does nothing.
  */
-export declare function noOp(): void
+export declare function noOp(): void;
 /**
  * Return a function, which executed {@param toThrottle} only after it is not invoked for {@param timeout} ms.
  * Executes function with the last passed arguments
  * @return {Function}
  */
-export declare function debounce<F extends (...args: any) => void>(timeout: number, toThrottle: F): F
+export declare function debounce<F extends (...args: any) => void>(timeout: number, toThrottle: F): F;
 /**
  * Returns a debounced function. When invoked for the first time, will just invoke
  * {@param toThrottle}. On subsequent invocations it will either invoke it right away
@@ -65,67 +59,67 @@ export declare function debounce<F extends (...args: any) => void>(timeout: numb
  * So the first and the last invocations in a series of invocations always take place
  * but ones in the middle (which happen too often) are discarded.}
  */
-export declare function debounceStart<F extends (...args: any) => void>(timeout: number, toThrottle: F): F
-export declare function randomIntFromInterval(min: number, max: number): number
-export declare function errorToString(error: Error): string
+export declare function debounceStart<F extends (...args: any) => void>(timeout: number, toThrottle: F): F;
+export declare function randomIntFromInterval(min: number, max: number): number;
+export declare function errorToString(error: Error): string;
 /**
  * Like {@link Object.entries} but preserves the type of the key and value
  */
-export declare function objectEntries<A extends string | symbol, B>(object: Record<A, B>): Array<[A, B]>
+export declare function objectEntries<A extends string | symbol, B>(object: Record<A, B>): Array<[A, B]>;
 /**
  * modified deepEquals from ospec is only needed as long as we use custom classes (TypeRef) and Date is not properly handled
  */
-export declare function deepEqual(a: any, b: any): boolean
+export declare function deepEqual(a: any, b: any): boolean;
 /**
  * returns an array of top-level properties that are in both objA and objB, but differ in value
  * does not handle functions or circular references
  * treats undefined and null as equal
  */
-export declare function getChangedProps(objA: any, objB: any): Array<string>
+export declare function getChangedProps(objA: any, objB: any): Array<string>;
 /**
  * Disallow set, delete and clear on Map.
  * Important: It is *not* a deep freeze.
  * @param myMap
  * @return {unknown}
  */
-export declare function freezeMap<K, V>(myMap: Map<K, V>): Map<K, V>
-export declare function addressDomain(senderAddress: string): string
+export declare function freezeMap<K, V>(myMap: Map<K, V>): Map<K, V>;
+export declare function addressDomain(senderAddress: string): string;
 /**
  * Ignores the fact that Object.keys returns also not owned properties.
  */
-export declare function typedKeys<K extends string, V>(obj: Record<K, V>): Array<K>
+export declare function typedKeys<K extends string, V>(obj: Record<K, V>): Array<K>;
 /**
  * Ignores the fact that Object.keys returns also not owned properties.
  */
-export declare function typedEntries<K extends string, V>(obj: Record<K, V>): Array<[K, V]>
+export declare function typedEntries<K extends string, V>(obj: Record<K, V>): Array<[K, V]>;
 /**
  * Ignores the fact that Object.keys returns also not owned properties.
  */
-export declare function typedValues<K extends string, V>(obj: Record<K, V>): Array<V>
-export declare type MaybeLazy<T> = T | lazy<T>
-export declare function resolveMaybeLazy<T>(maybe: MaybeLazy<T>): T
-export declare function getAsLazy<T>(maybe: MaybeLazy<T>): lazy<T>
-export declare function mapLazily<T, U>(maybe: MaybeLazy<T>, mapping: (arg0: T) => U): lazy<U>
+export declare function typedValues<K extends string, V>(obj: Record<K, V>): Array<V>;
+export declare type MaybeLazy<T> = T | lazy<T>;
+export declare function resolveMaybeLazy<T>(maybe: MaybeLazy<T>): T;
+export declare function getAsLazy<T>(maybe: MaybeLazy<T>): lazy<T>;
+export declare function mapLazily<T, U>(maybe: MaybeLazy<T>, mapping: (arg0: T) => U): lazy<U>;
 /**
  * Stricter version of parseInt() from MDN. parseInt() allows some arbitrary characters at the end of the string.
  * Returns NaN in case there's anything non-number in the string.
  */
-export declare function filterInt(value: string): number
+export declare function filterInt(value: string): number;
 interface Positioned {
-	x: number
-	y: number
+    x: number;
+    y: number;
 }
 interface Sized {
-	top: number
-	left: number
-	bottom: number
-	right: number
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
 }
-export declare function insideRect(point: Positioned, rect: Sized): boolean
+export declare function insideRect(point: Positioned, rect: Sized): boolean;
 /**
  * If val is non null, returns the result of val passed to action, else null
  */
-export declare function mapNullable<T, U>(val: T | null | undefined, action: (arg0: T) => U | null | undefined): U | null
+export declare function mapNullable<T, U>(val: T | null | undefined, action: (arg0: T) => U | null | undefined): U | null;
 /** Helper to take instead of `typeof setTimeout` which is hellish to reproduce */
-export declare type TimeoutSetter = (fn: () => unknown, arg1: number) => ReturnType<typeof setTimeout>
-export {}
+export declare type TimeoutSetter = (fn: () => unknown, arg1: number) => ReturnType<typeof setTimeout>;
+export {};