@tutao/tutanota-utils 3.91.2 → 3.91.3

package/dist/ArrayUtils.d.ts

@@ -0,0 +1,148 @@
+export declare function concat(...arrays: Uint8Array[]): Uint8Array;
+export declare function numberRange(min: number, max: number): Array<number>;
+/**
+ * Compares two arrays for equality based on ===.
+ * @param {Array} a1 The first array.
+ * @param {Array} a2 The second array.
+ * @return {boolean} True if the arrays are equal, false otherwise.
+ *
+ * It is valid to compare Uint8Array to Array<T>, don't restrict it to be one type
+ */
+export declare function arrayEquals<T, A extends Uint8Array | Array<T>>(a1: A, a2: A): boolean;
+/**
+ * Compares two arrays for equality based on a predicate
+ * @param a1
+ * @param a2
+ * @param predicate
+ * @returns {boolean}
+ */
+export declare function arrayEqualsWithPredicate<T>(a1: ReadonlyArray<T>, a2: ReadonlyArray<T>, predicate: (arg0: T, arg1: T) => boolean): boolean;
+export declare function arrayHash(array: Uint8Array): number;
+/**
+ * Remove the element from theArray if it is contained in the array.
+ * @param theArray The array to remove the element from.
+ * @param elementToRemove The element to remove from the array.
+ * @return True if the element was removed, false otherwise.
+ */
+export declare function remove<T>(theArray: Array<T>, elementToRemove: T): boolean;
+/**
+ * Find all items in an array that pass the given predicate
+ */
+export declare function findAll<T>(theArray: Array<T>, finder: (arg0: T) => boolean): Array<T>;
+/**
+ * @param theArray
+ * @param finder
+ * @return {boolean} if the element was found
+ */
+export declare function findAndRemove<T>(theArray: Array<T>, finder: (arg0: T) => boolean): boolean;
+export declare function findAllAndRemove<T>(theArray: Array<T>, finder: (arg0: T) => boolean, startIndex?: number): boolean;
+export declare function replace(theArray: Array<any>, oldElement: any, newElement: any): boolean;
+/**
+ * Same as filterMap in some languages. Apply mapper and then only include non-nullable items.
+ */
+export declare function mapAndFilterNull<T, R>(array: ReadonlyArray<T>, mapper: (arg0: T) => R | null | undefined): Array<R>;
+export declare function filterNull<T>(array: ReadonlyArray<T | null | undefined>): Array<T>;
+/**
+ * Provides the last element of the given array.
+ * @param theArray The array.
+ * @return The last element of the array.
+ */
+export declare function last<T>(theArray: ReadonlyArray<T>): T | null | undefined;
+export declare function isEmpty<T>(array: ReadonlyArray<T>): boolean;
+export declare function lastThrow<T>(array: ReadonlyArray<T>): T;
+export declare function firstThrow<T>(array: ReadonlyArray<T>): T;
+export declare function first<T>(array: ReadonlyArray<T>): T | null;
+export declare function findLast<T>(array: Array<T>, predicate: (arg0: T) => boolean): T | null | undefined;
+export declare function findLastIndex<T>(array: Array<T>, predicate: (arg0: T) => boolean): number;
+export declare function contains(theArray: Array<any>, elementToCheck: any): boolean;
+export declare function addAll(array: Array<any>, elements: Array<any>): void;
+export declare function removeAll(array: Array<any>, elements: Array<any>): void;
+/**
+ * Group an array based on the given discriminator, but each group will have only unique items
+ */
+export declare function groupByAndMapUniquely<T, R, E>(iterable: Iterable<T>, discriminator: (arg0: T) => R, mapper: (arg0: T) => E): Map<R, Set<E>>;
+/**
+ * convert an Array of T's into a Map of Arrays of E's by
+ * * grouping them based on a discriminator
+ * * mapping them from T to E
+ * @param iterable the array to split into groups
+ * @param discriminator a function that produces the keys to group the elements by
+ * @param mapper a function that maps the array elements before they get added to the group
+ * @returns {Map<R, Array<E>>}
+ */
+export declare function groupByAndMap<T, R, E>(iterable: Iterable<T>, discriminator: (arg0: T) => R, mapper: (arg0: T) => E): Map<R, Array<E>>;
+/**
+ * Group array elements based on keys produced by a discriminator
+ * @param iterable the array to split into groups
+ * @param discriminator a function that produces the keys to group the elements by
+ * @returns {NodeJS.Global.Map<R, Array<T>>}
+ */
+export declare function groupBy<T, R>(iterable: Iterable<T>, discriminator: (arg0: T) => R): Map<R, Array<T>>;
+/**
+ * split an array into chunks of a given size.
+ * the last chunk will be smaller if there are less than chunkSize elements left.
+ * @param chunkSize
+ * @param array
+ * @returns {Array<Array<T>>}
+ */
+export declare function splitInChunks<T>(chunkSize: number, array: Array<T>): Array<Array<T>>;
+export declare function flat<T>(arrays: ReadonlyArray<ReadonlyArray<T>>): Array<T>;
+/**
+ * Maps an array into a nested array and then flattens it
+ * @param array
+ * @param mapper
+ * @returns {T|*[]}
+ */
+export declare function flatMap<T, U>(array: ReadonlyArray<T>, mapper: (arg0: T) => Array<U>): Array<U>;
+/**
+ * Inserts element into the sorted array. Will find <b>the last</b> matching position.
+ * Might add or replace element based on {@param replaceIf} identity check.
+ * Equality per {@param comparator} is precondition for replacement.
+ * @param element to place
+ * @param array where element should be placed
+ * @param comparator for sorting
+ * @param replaceIf identity comparison for replacement
+ */
+export declare function insertIntoSortedArray<T>(element: T, array: Array<T>, comparator: (left: T, right: T) => number, replaceIf?: (newElement: T, existing: T) => boolean): void;
+export declare function zip<A, B>(arr1: Array<A>, arr2: Array<B>): Array<[A, B]>;
+export declare function deduplicate<T>(arr: Array<T>, comp?: (arg0: T, arg1: T) => boolean): Array<T>;
+/**
+ * http://jsfiddle.net/aryzhov/pkfst550/
+ * Binary search in JavaScript.
+ * Returns the index of of the element in a sorted array or (-n-1) where n is the insertion point for the new element.
+ * Parameters:
+ *     ar - A sorted array
+ *     el - An element to search for
+ *     compare_fn - A comparator function. The function takes two arguments: (a, b) and returns:
+ *        a negative number  if a is less than b;
+ *        0 if a is equal to b;
+ *        a positive number of a is greater than b.
+ * The array may contain duplicate elements. If there are more than one equal elements in the array,
+ * the returned value can be the index of any one of the equal elements.
+ */
+export declare function binarySearch<T>(ar: Array<T>, el: T, compare_fn: (arg0: T, arg1: T) => number): number;
+export declare function lastIndex<T>(array: ReadonlyArray<T>): number;
+/**
+ * All of the elements in all of the arguments combined, and deduplicated
+ */
+export declare function union<T>(...iterables: Array<Iterable<T>>): Set<T>;
+/**
+ * return a new array containing every item from array1 that isn't in array2
+ * @param array1
+ * @param array2
+ * @param compare: compare items in the array for equality
+ * @returns {Array<$NonMaybeType<T>>|Array<T>}
+ */
+export declare function difference<T>(array1: ReadonlyArray<T>, array2: ReadonlyArray<T>, compare?: (arg0: T, arg1: T) => boolean): Array<T>;
+/**
+ * Returns a set with elements that are *not* in both sets.
+ *
+ * {a, b, c} △ {b, c, d} == {a, d}
+ */
+export declare function symmetricDifference<T>(set1: ReadonlySet<T>, set2: ReadonlySet<T>): Set<T>;
+/**
+ * Splits an array into two based on a predicate, where elements that match the predicate go into the left side
+ * @param array
+ * @param predicate
+ */
+export declare function partition<T>(array: Array<T>, predicate: (arg0: T) => boolean): [Array<T>, Array<T>];

package/dist/ArrayUtils.js

@@ -0,0 +1,410 @@
+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;
+}
+export function numberRange(min, max) {
+    return [...Array(max + 1).keys()].slice(min);
+}
+/**
+ * Compares two arrays for equality based on ===.
+ * @param {Array} a1 The first array.
+ * @param {Array} a2 The second array.
+ * @return {boolean} True if the arrays are equal, false otherwise.
+ *
+ * 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;
+}
+/**
+ * Compares two arrays for equality based on a predicate
+ * @param a1
+ * @param a2
+ * @param predicate
+ * @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;
+}
+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;
+}
+/**
+ * Remove the element from theArray if it is contained in the array.
+ * @param theArray The array to remove the element from.
+ * @param elementToRemove The element to remove from the 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;
+    }
+}
+/**
+ * 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;
+}
+/**
+ * @param theArray
+ * @param 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;
+    }
+}
+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;
+}
+export function replace(theArray, oldElement, newElement) {
+    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;
+}
+export function filterNull(array) {
+    return downcast(array.filter(item => item != null));
+}
+/**
+ * Provides the last element of the given array.
+ * @param theArray The array.
+ * @return The last element of the array.
+ */
+export function last(theArray) {
+    return theArray[theArray.length - 1];
+}
+export function isEmpty(array) {
+    return array.length === 0;
+}
+export function lastThrow(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];
+}
+export function first(array) {
+    return array[0] || null;
+}
+export function findLast(array, predicate) {
+    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;
+}
+export function contains(theArray, elementToCheck) {
+    return theArray.indexOf(elementToCheck) !== -1;
+}
+export function addAll(array, elements) {
+    array.push(...elements);
+}
+export function removeAll(array, elements) {
+    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;
+}
+/**
+ * convert an Array of T's into a Map of Arrays of E's by
+ * * grouping them based on a discriminator
+ * * mapping them from T to E
+ * @param iterable the array to split into groups
+ * @param discriminator a function that produces the keys to group the elements by
+ * @param mapper a function that maps the array elements before they get added to the group
+ * @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;
+}
+/**
+ * Group array elements based on keys produced by a discriminator
+ * @param iterable the array to split into groups
+ * @param discriminator a function that produces the keys to group the elements by
+ * @returns {NodeJS.Global.Map<R, Array<T>>}
+ */
+export function groupBy(iterable, discriminator) {
+    return groupByAndMap(iterable, discriminator, identity);
+}
+/**
+ * split an array into chunks of a given size.
+ * the last chunk will be smaller if there are less than chunkSize elements left.
+ * @param chunkSize
+ * @param array
+ * @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;
+}
+export function flat(arrays) {
+    return arrays.flat();
+}
+/**
+ * Maps an array into a nested array and then flattens it
+ * @param array
+ * @param mapper
+ * @returns {T|*[]}
+ */
+export function flatMap(array, mapper) {
+    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.
+ * Might add or replace element based on {@param replaceIf} identity check.
+ * Equality per {@param comparator} is precondition for replacement.
+ * @param element to place
+ * @param array where element should be placed
+ * @param comparator for sorting
+ * @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);
+}
+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;
+}
+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;
+}
+/**
+ * http://jsfiddle.net/aryzhov/pkfst550/
+ * Binary search in JavaScript.
+ * Returns the index of of the element in a sorted array or (-n-1) where n is the insertion point for the new element.
+ * Parameters:
+ *     ar - A sorted array
+ *     el - An element to search for
+ *     compare_fn - A comparator function. The function takes two arguments: (a, b) and returns:
+ *        a negative number  if a is less than b;
+ *        0 if a is equal to b;
+ *        a positive number of a is greater than b.
+ * The array may contain duplicate elements. If there are more than one equal elements in the array,
+ * 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;
+}
+export function lastIndex(array) {
+    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 a new array containing every item from array1 that isn't in array2
+ * @param array1
+ * @param array2
+ * @param compare: compare items in the array for equality
+ * @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)));
+}
+/**
+ * Returns a set with elements that are *not* in both sets.
+ *
+ * {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;
+}
+/**
+ * Splits an array into two based on a predicate, where elements that match the predicate go into the left side
+ * @param array
+ * @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];
+}

package/dist/AsyncResult.d.ts

@@ -0,0 +1,23 @@
+declare type StatePending<T> = {
+    status: "pending";
+    promise: Promise<T>;
+};
+declare type StateComplete<T> = {
+    status: "complete";
+    result: T;
+};
+declare type StateFailure = {
+    status: "failure";
+    error: any;
+};
+declare type AsyncResultState<T> = StatePending<T> | StateComplete<T> | StateFailure;
+/**
+ * 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 {};

package/dist/AsyncResult.js

@@ -0,0 +1,31 @@
+/**
+ * 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 class AsyncResult {
+    constructor(promise) {
+        this._state = pending(promise);
+        promise.then(result => (this._state = complete(result))).catch(error => (this._state = failure(error)));
+    }
+    state() {
+        return this._state;
+    }
+}
+function pending(promise) {
+    return {
+        status: "pending",
+        promise,
+    };
+}
+function complete(result) {
+    return {
+        status: "complete",
+        result,
+    };
+}
+function failure(error) {
+    return {
+        status: "failure",
+        error,
+    };
+}

package/dist/CollectionUtils.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Everything that is in both array1 and array2
+ * This is a naive implementation, don't use it on large inputs
+ */
+export declare function intersection<T>(set1: Set<T>, set2: Set<T>): Set<T>;

package/dist/CollectionUtils.js

@@ -0,0 +1,7 @@
+/**
+ * Everything that is in both array1 and array2
+ * This is a naive implementation, don't use it on large inputs
+ */
+export function intersection(set1, set2) {
+    return new Set(Array.from(set1).filter(item => set2.has(item)));
+}

package/dist/DateUtils.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @file DateUtils which do not use Luxon. Used in worker as well as in client parts.
+ * As functions here do not use Luxon it cannot be used for calculating things in different time zones, they
+ * are dependent on the system time zone.
+ */
+export declare const DAY_IN_MILLIS: number;
+/**
+ * Provides a date representing the beginning of the next day of the given date in local time.
+ */
+export declare function getStartOfNextDay(date: Date): Date;
+/**
+ * Provides a date representing the end of the given date in local time.
+ */
+export declare function getEndOfDay(date: Date): Date;
+/**
+ * Provides a date representing the beginning of the given date in local time.
+ */
+export declare function getStartOfDay(date: Date): Date;
+/**
+ * Provides a date representing the day of the given date at the given hour in local time.
+ */
+export declare function getHourOfDay(date: Date, hour: number): Date;
+export declare function isStartOfDay(date: Date): boolean;
+/**
+ * Returns true if the given date is today in local time.
+ */
+export declare function isToday(date: Date): boolean;
+/**
+ * Returns true if the given dates represent the same day (time of day is ignored).
+ */
+export declare function isSameDay(date1: Date, date2: Date): boolean;
+/**
+ * Creates new date in with {@param days} added to it as if the days are just fixed
+ * periods of time and are not subject to daylight saving.
+ */
+export declare function getDayShifted(date: Date, days: number): Date;
+/**
+ * Increment the date in place and return it
+ */
+export declare function incrementDate(date: Date, byValue: number): Date;
+export declare function incrementMonth(d: Date, byValue: number): Date;
+export declare function isSameDayOfDate(date1: Date | null | undefined, date2: Date | null | undefined): boolean;
+/**
+ * Formats as yyyy-mm-dd
+ */
+export declare function formatSortableDate(date: Date): string;
+/**
+ * Formats as yyyy-mm-dd-<hh>h-<mm>m-<ss>
+ */
+export declare function formatSortableDateTime(date: Date): string;
+/**
+ * @returns {string} sortableDateTime of the current time
+ */
+export declare function sortableTimestamp(): string;
+export declare function isValidDate(date: Date): boolean;
+/**
+ * not interested in any fancy calendar edge cases, only use this where approximation is ok
+ */
+export declare function millisToDays(millis: number): number;
+export declare function daysToMillis(days: number): number;