@tutao/tutanota-utils 3.89.24 → 3.91.2

package/lib/PromiseUtils.js

@@ -1,144 +0,0 @@
-//@flow
-import type {Options as PromiseMapOptions} from "./PromiseMap"
-import {pMap as promiseMap} from "./PromiseMap"
-
-export type $Promisable<+T> = Promise<T> | T;
-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 function mapInCallContext<T, U>(values: T[], callback: PromiseMapCallback<T, U>): PromisableWrapper<Array<U>> {
-	return new PromisableWrapper(_mapInCallContext(values, callback, 0, []))
-}
-
-function _mapInCallContext<T, U>(values: T[], callback: PromiseMapCallback<T, U>, index: number, acc: U[]): $Promisable<Array<U>> {
-	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"
-
-export type PromiseMapFn = <T, U>(values: T[], callback: PromiseMapCallback<T, U>, options?: PromiseMapOptions) => PromisableWrapper<U[]>
-
-function mapNoFallback<T, U>(values: Array<T>, callback: PromiseMapCallback<T, U>, options?: PromiseMapOptions) {
-	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: boolean): PromiseMapFn {
-	return useMapInCallContext ? mapInCallContext : mapNoFallback
-}
-
-function flatWrapper<T>(value: PromisableWrapper<T> | T): $Promisable<T> {
-	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<T> {
-	static from(value: $Promisable<T>): PromisableWrapper<T> {
-		return new PromisableWrapper(value)
-	}
-
-	value: $Promisable<T>;
-
-	constructor(value: $Promisable<PromisableWrapper<T> | T>) {
-		this.value = value instanceof Promise ? value.then(flatWrapper) : flatWrapper(value);
-	}
-
-	thenOrApply<R>(onFulfill: (T) => $Promisable<PromisableWrapper<R> | R>, onReject?: (any) => $Promisable<R | PromisableWrapper<R>>): PromisableWrapper<R> {
-		if (this.value instanceof Promise) {
-			const v: Promise<PromisableWrapper<R> | R> = this.value.then(onFulfill, onReject)
-			return new PromisableWrapper(v)
-		} else {
-			try {
-				return new PromisableWrapper(onFulfill(this.value))
-			} catch (e) {
-				if (onReject) {
-					return new PromisableWrapper<R>(onReject(e))
-				}
-				throw e
-			}
-		}
-	}
-
-	toPromise(): Promise<T> {
-		return Promise.resolve(this.value)
-	}
-}
-
-export function delay(ms: number): Promise<void> {
-	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<T>(action: T => mixed): T => T {
-	return function (value) {
-		action(value)
-		return value
-	}
-}
-
-/**
- * Helper utility intended to be used with typed excpetions 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<E, R>(cls: Class<E>, catcher: (E) => $Promisable<R>): ((any) => Promise<R>) {
-	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<T>(iterable: Iterable<T>, filter: (item: T, index: number) => $Promisable<boolean>): Promise<Array<T>> {
-	let index = 0
-	const result = []
-	for (let item of iterable) {
-		if (await filter(item, index)) {
-			result.push(item)
-		}
-		index++
-	}
-	return result
-}

package/lib/SortedArray.js

@@ -1,66 +0,0 @@
-// @flow
-
-import {findAndRemove, insertIntoSortedArray} from "./ArrayUtils"
-
-export type CompareFn<T> = (T, T) => number
-
-/**
- * Compared based on the type's natural ordering
- * @param a
- * @param b
- * @returns {number}
- */
-// <T: Object> to get flow off my back about using comparison operator
-// It should be fine for 99% of use cases? worst case it just returns 0 always
-function defaultCompare<T: Object>(a: T, b: T): number {
-	return a < b
-		? -1
-		: a > b
-			? 1 : 0
-}
-
-/**
- * An array that keeps itself sorted
- */
-export class SortedArray<T> {
-	+_contents: Array<T>
-	+_compareFn: CompareFn<T>
-
-	constructor(compareFn: CompareFn<T> = defaultCompare) {
-		this._contents = []
-		this._compareFn = compareFn
-	}
-
-	static from(array: $ReadOnlyArray<T>, compareFn?: CompareFn<T>): SortedArray<T> {
-		const list = new SortedArray<T>(compareFn)
-		list.insertAll(array)
-		return list
-	}
-
-	get length(): number {
-		return this._contents.length
-	}
-
-	get array(): $ReadOnlyArray<T> {
-		return this._contents
-	}
-
-	get(index: number): T {
-		return this._contents[index]
-	}
-
-	insertAll(array: $ReadOnlyArray<T>) {
-		this._contents.push(...array)
-		this._contents.sort(this._compareFn)
-	}
-
-	insert(item: T): void {
-		insertIntoSortedArray(item, this._contents, this._compareFn)
-	}
-
-	removeFirst(finder: (T) => boolean): boolean {
-		return findAndRemove(this._contents, finder)
-	}
-}
-
-

package/lib/StringUtils.js

@@ -1,126 +0,0 @@
-// @flow
-
-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 function pad(num: number, size: number): string {
-	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: string, substring: string): boolean {
-	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: string): string {
-	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: string, substring: string): boolean {
-	return string.endsWith(substring)
-}
-
-
-export function lazyStringValue(valueOrLazy: string | lazy<string>): string {
-	return typeof valueOrLazy === "function"
-		? valueOrLazy()
-		: valueOrLazy
-}
-
-export function repeat(value: string, length: number): string {
-	let result = ""
-	for (let i = 0; i < length; i++) {
-		result += value;
-	}
-	return result
-}
-
-export function cleanMatch(s1: string, s2: string): boolean {
-	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: string, index: number): [string, string] {
-	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: string): string {
-	return str.toLowerCase()
-}
-
-/**
- * Wrapper around String.prototype.localeCompare, for passing to Array.prototype.sort
- * @param a
- * @param b
- * @returns {number}
- */
-export function localeCompare(a: string, b: string): number {
-	return a.localeCompare(b)
-}
-
-export function byteLength(str: ?string): number {
-	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: string, substr: string, replacement: string): string {
-	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: string, flags: string): RegExp {
-	return new RegExp(str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), flags)
-}

package/lib/TypeRef.js

@@ -1,25 +0,0 @@
-//@flow
-
-/**
- * Attention: TypeRef must be defined as class and not as Flow type because object types use structural typing and TypeRef does not
- * reference T. See https://github.com/facebook/flow/issues/3348
- * T should be bound to entities but we have no type to define them yet.
- */
-export class TypeRef<+T> {
-	+app: string;
-	+type: string;
-
-	constructor(app: string, type: string) {
-		this.app = app
-		this.type = type
-		Object.freeze(this)
-	}
-}
-
-export function isSameTypeRefByAttr(typeRef: TypeRef<any>, app: string, type: string): boolean {
-	return typeRef.app === app && typeRef.type === type
-}
-
-export function isSameTypeRef(typeRef1: TypeRef<any>, typeRef2: TypeRef<any>): boolean {
-	return isSameTypeRefByAttr(typeRef1, typeRef2.app, typeRef2.type)
-}