@tutao/tutanota-utils 3.91.2 → 3.91.3

package/dist/MathUtils.js

@@ -0,0 +1,9 @@
+export function mod(n, 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));
+}

package/dist/PromiseMap.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @file Vendored version of p-map: https://github.com/sindresorhus/p-map/
+ * Vendored to avoid having dependency on AggregateError.
+ *
+ * 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;
+}
+/**
+    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;
+/**
+    @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.
+    @param options
+    @returns A `Promise` that is fulfilled when all promises in `input` and ones returned from `mapper` are fulfilled, or rejects if any of the promises reject. The fulfilled value is an `Array` of the fulfilled values returned from `mapper` in `input` order.
+    @example
+    ```
+    import pMap from 'p-map';
+    import got from 'got';
+    const sites = [
+        getWebsiteFromUsername('sindresorhus'), //=> Promise
+        'https://avajs.dev',
+        'https://github.com'
+    ];
+    const mapper = async site => {
+        const {requestUrl} = await got.head(site);
+        return requestUrl;
+    };
+    const result = await pMap(sites, mapper, {concurrency: 2});
+    console.log(result);
+    //=> ['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>>;

package/dist/PromiseMap.js

@@ -0,0 +1,75 @@
+/**
+    @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.
+    @param options
+    @returns A `Promise` that is fulfilled when all promises in `input` and ones returned from `mapper` are fulfilled, or rejects if any of the promises reject. The fulfilled value is an `Array` of the fulfilled values returned from `mapper` in `input` order.
+    @example
+    ```
+    import pMap from 'p-map';
+    import got from 'got';
+    const sites = [
+        getWebsiteFromUsername('sindresorhus'), //=> Promise
+        'https://avajs.dev',
+        'https://github.com'
+    ];
+    const mapper = async site => {
+        const {requestUrl} = await got.head(site);
+        return requestUrl;
+    };
+    const result = await pMap(sites, mapper, {concurrency: 2});
+    console.log(result);
+    //=> ['https://sindresorhus.com/', 'https://avajs.dev/', 'https://github.com/']
+    ```
+ */
+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;
+            }
+        }
+    });
+}

package/dist/PromiseUtils.d.ts

@@ -0,0 +1,48 @@
+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.
+ *
+ * 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[]>;
+/** Factory function which gives you ack promiseMap implementation. {@see mapInCallContext} for what it means. */
+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>;
+}
+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;
+/**
+ * Helper utility intended to be used with typed exceptions and .catch() method of promise like so:
+ *
+ * ```js
+ *  class SpecificError extends Error {}
+ *
+ *  Promise.reject(new SpecificError())
+ *      .catch(ofClass(SpecificError, (e) => console.log("some error", e)))
+ *      .catch((e) => console.log("generic error", e))
+ * ```
+ *
+ * @param cls Class which will be caught
+ * @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>;
+/**
+ * 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>>;

package/dist/PromiseUtils.js

@@ -0,0 +1,127 @@
+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.
+ *
+ * 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 function mapInCallContext(values, callback) {
+    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);
+    }
+}
+export { pMap as promiseMap } from "./PromiseMap.js";
+function mapNoFallback(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;
+}
+function flatWrapper(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);
+    }
+}
+export function delay(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;
+    };
+}
+/**
+ * Helper utility intended to be used with typed exceptions and .catch() method of promise like so:
+ *
+ * ```js
+ *  class SpecificError extends Error {}
+ *
+ *  Promise.reject(new SpecificError())
+ *      .catch(ofClass(SpecificError, (e) => console.log("some error", e)))
+ *      .catch((e) => console.log("generic error", e))
+ * ```
+ *
+ * @param cls Class which will be caught
+ * @param catcher to handle only errors of type cls
+ * @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;
+        }
+    };
+}
+/**
+ * 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;
+}

package/dist/SortedArray.d.ts

@@ -0,0 +1,16 @@
+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;
+}

package/dist/SortedArray.js

@@ -0,0 +1,44 @@
+import { findAndRemove, insertIntoSortedArray } from "./ArrayUtils.js";
+/**
+ * Compared based on the type's natural ordering
+ * @param a
+ * @param b
+ * @returns {number}
+ */
+// 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;
+}
+/**
+ * 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);
+    }
+}

package/dist/StringUtils.d.ts

@@ -0,0 +1,58 @@
+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;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * Non-breaking space character
+ */
+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];
+/**
+ * Wrapper around String.prototype.toLowerCase, nice for calls to Array.prototype.map
+ * @param str
+ */
+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;
+/**
+ * replace all instances of substr in str with replacement
+ */
+export declare function replaceAll(str: string, substr: string, replacement: string): string;

package/dist/StringUtils.js

@@ -0,0 +1,110 @@
+/**
+ * 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 function pad(num, size) {
+    var s = num + "";
+    while (s.length < size)
+        s = "0" + s;
+    return s;
+}
+/**
+ * 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 function startsWith(string, substring) {
+    return string.startsWith(substring);
+}
+/**
+ * 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 function capitalizeFirstLetter(str) {
+    return str[0].toUpperCase() + str.toLowerCase().slice(1);
+}
+/**
+ * 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 function endsWith(string, substring) {
+    return string.endsWith(substring);
+}
+export function lazyStringValue(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;
+}
+export function cleanMatch(s1, s2) {
+    return s1.toLowerCase().trim() === s2.toLowerCase().trim();
+}
+/**
+ * Non-breaking space character
+ */
+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)];
+}
+/**
+ * Wrapper around String.prototype.toLowerCase, nice for calls to Array.prototype.map
+ * @param str
+ */
+export function toLowerCase(str) {
+    return str.toLowerCase();
+}
+/**
+ * Wrapper around String.prototype.localeCompare, for passing to Array.prototype.sort
+ * @param a
+ * @param b
+ * @returns {number}
+ */
+export function localeCompare(a, 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;
+}
+/**
+ * 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);
+}
+/**
+ * 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);
+}

package/dist/TypeRef.d.ts

@@ -0,0 +1,12 @@
+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);
+}
+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

@@ -0,0 +1,19 @@
+// 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);
+    }
+}
+export function isSameTypeRefByAttr(typeRef, app, type) {
+    return typeRef.app === app && typeRef.type === type;
+}
+export function isSameTypeRef(typeRef1, typeRef2) {
+    return isSameTypeRefByAttr(typeRef1, typeRef2.app, typeRef2.type);
+}