@tutao/tutanota-utils 3.93.5 → 3.94.0

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,10 +5,9 @@
  * @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.
@@ -17,7 +16,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
@@ -25,7 +24,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.
@@ -34,39 +33,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
@@ -75,36 +74,32 @@ 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,12 +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);
+	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,19 +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);
-    }
+	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,57 +1,63 @@
-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
@@ -59,67 +65,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 {}