@tutao/tutanota-utils 3.89.23 → 3.91.1

package/README.md

@@ -3,9 +3,4 @@
 This is a collection of common utils we use across multiple projects/modules internally. As creating this module really
 is just an intermediate step towards re-organising some of the dependency structure of our software, it is most likely
 going to change a lot in the future and might even disappear altogether. For these reasons **we strongly discourage
-anyone outside of our organisation to directly depend on this module**.
-
-For now we only provide this as a flow-typed source module and not compiled for ES6 or CJS. The reason is that our
-current tooling (flow, rollup, webstorm) will not allow us to use the compiled version directly without putting a lot of
-effort into restructuring the way we build tutanota and/or changing some of our tools or losing some convenient IDE
-features such as usage search.
+anyone outside of our organisation to directly depend on this module**.

package/package.json

@@ -1,35 +1,27 @@
 {
 	"name": "@tutao/tutanota-utils",
-	"version": "3.89.23",
+	"version": "3.91.1",
 	"license": "GPL-3.0",
-	"main": "./lib/index.js",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/tutao/tutanota.git",
 		"directory": "packages/tutanota-utils"
 	},
 	"scripts": {
-		"flow": "flow; test $? -eq 0 -o $? -eq 2",
-		"test": "rollup --config rollup_test.config.js && node 'build/test/Suite.js'"
+		"test": "rm -r build; tsc --project test/tsconfig.json && cd build/test && node 'Suite.js'",
+		"build": "rm -r dist; tsc"
 	},
 	"type": "module",
 	"files": [
-		"lib/*",
+		"dist/*",
 		"README.md",
 		"LICENSE.txt"
 	],
 	"devDependencies": {
-		"@babel/core": "7.14.6",
-		"@babel/plugin-proposal-class-properties": "7.14.5",
-		"@babel/plugin-transform-flow-strip-types": "7.4.4",
-		"@babel/plugin-proposal-nullish-coalescing-operator": "7.14.5",
-		"@babel/plugin-proposal-optional-chaining": "7.14.5",
-		"@rollup/plugin-commonjs": "21.0.1",
-		"@rollup/plugin-babel": "5.2.2",
-		"@rollup/plugin-node-resolve": "11.0.1",
-		"flow-bin": "0.152.0",
-		"rollup": "2.55.1",
-		"@tutao/tutanota-test-utils": "3.89.23",
+		"@tutao/tutanota-test-utils": "3.91.1",
+		"typescript": "4.5.4",
 		"ospec": "https://github.com/tutao/ospec.git#0472107629ede33be4c4d19e89f237a6d7b0cb11"
 	}
 }

package/lib/ArrayUtils.js

@@ -1,444 +0,0 @@
-//@flow
-import {downcast, identity, neverNull} from "./Utils"
-import {getFromMap} from "./MapUtils"
-
-export function concat(...arrays: Uint8Array[]): Uint8Array {
-	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: number, max: number): Array<number> {
-	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<T, A: Uint8Array | Array<T>>(a1: A, a2: A): boolean {
-	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<T>(a1: $ReadOnlyArray<T>, a2: $ReadOnlyArray<T>, predicate: (T, T) => boolean): boolean {
-	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: Uint8Array): number {
-	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<T>(theArray: Array<T>, elementToRemove: T): boolean {
-	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<T>(theArray: Array<T>, finder: (T) => boolean): Array<T> {
-	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<T>(theArray: Array<T>, finder: (T) => boolean): boolean {
-	const index = theArray.findIndex(finder)
-	if (index !== -1) {
-		theArray.splice(index, 1)
-		return true
-	} else {
-		return false
-	}
-}
-
-export function findAllAndRemove<T>(theArray: Array<T>, finder: (T) => boolean, startIndex: number = 0): boolean {
-	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: Array<any>, oldElement: any, newElement: any): boolean {
-	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<T, R>(array: $ReadOnlyArray<T>, mapper: (T) => ?R): Array<R> {
-	const resultList = []
-	for (const item of array) {
-		const resultItem = mapper(item)
-		if (resultItem != null) {
-			resultList.push(resultItem)
-		}
-	}
-	return resultList
-}
-
-export function filterNull<T>(array: $ReadOnlyArray<?T>): Array<T> {
-	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<T>(theArray: $ReadOnlyArray<T>): ?T {
-	return theArray[theArray.length - 1];
-}
-
-export function isEmpty<T>(array: $ReadOnlyArray<T>): boolean {
-	return array.length === 0
-}
-
-export function lastThrow<T>(array: $ReadOnlyArray<T>): T {
-	if (isEmpty(array)) {
-		throw new RangeError("Array is empty")
-	}
-	return neverNull(last(array))
-}
-
-export function firstThrow<T>(array: $ReadOnlyArray<T>): T {
-	if (isEmpty(array)) {
-		throw new RangeError("Array is empty")
-	}
-	return array[0]
-}
-
-export function first<T>(array: $ReadOnlyArray<T>): T | null {
-	return array[0] || null
-}
-
-export function findLast<T>(array: Array<T>, predicate: (T) => boolean): ?T {
-	const index = findLastIndex(array, predicate)
-	if (index !== -1) {
-		return array[index]
-	}
-	return null
-}
-
-export function findLastIndex<T>(array: Array<T>, predicate: (T) => boolean): number {
-	for (let i = array.length - 1; i >= 0; i--) {
-		if (predicate(array[i])) {
-			return i
-		}
-	}
-	return -1
-}
-
-export function contains(theArray: Array<any>, elementToCheck: any): boolean {
-	return theArray.indexOf(elementToCheck) !== -1
-}
-
-export function addAll(array: Array<any>, elements: Array<any>) {
-	array.push(...elements)
-}
-
-export function removeAll(array: Array<any>, elements: Array<any>) {
-	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<T, R, E>(iterable: Iterable<T>, discriminator: T => R, mapper: T => E): Map<R, Set<E>> {
-	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<T, R, E>(iterable: Iterable<T>, discriminator: (T) => R, mapper: (T) => E): Map<R, Array<E>> {
-	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<T, R>(iterable: Iterable<T>, discriminator: (T) => R): Map<R, Array<T>> {
-	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<T>(chunkSize: number, array: Array<T>): Array<Array<T>> {
-	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<T>(arrays: $ReadOnlyArray<$ReadOnlyArray<T>>): Array<T> {
-	return arrays.reduce((acc, val) => {
-		acc.push(...val)
-		return acc
-	}, [])
-}
-
-/**
- * Maps an array into a nested array and then flattens it
- * @param array
- * @param mapper
- * @returns {T|*[]}
- */
-export function flatMap<T, U>(array: $ReadOnlyArray<T>, mapper: T => Array<U>): Array<U> {
-	return array.reduce((acc, val) => acc.concat(mapper(val)), [])
-}
-
-
-/**
- * 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<T>(element: T, array: Array<T>,
-                                         comparator: (left: T, right: T) => number,
-                                         replaceIf: (newElement: T, existing: T) => boolean = () => 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<A, B>(arr1: Array<A>, arr2: Array<B>): Array<[A, B]> {
-	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<T>(arr: Array<T>, comp: (T, T) => boolean = (a, b) => a === b): Array<T> {
-	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<T>(ar: Array<T>, el: T, compare_fn: (T, T) => number): number {
-	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<T>(array: $ReadOnlyArray<T>): number {
-	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<T>(...iterables: Array<Iterable<T>>): Set<T> {
-	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<T>(array1: $ReadOnlyArray<T>, array2: $ReadOnlyArray<T>, compare: (T, T) => boolean): Array<T> {
-	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<T>(set1: $ReadOnlySet<T>, set2: $ReadOnlySet<T>): Set<T> {
-	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<T>(array: Array<T>, predicate: T => boolean): [Array<T>, Array<T>] {
-	const left = []
-	const right = []
-	for (let item of array) {
-		if (predicate(item)) {
-			left.push(item)
-		} else {
-			right.push(item)
-		}
-	}
-
-	return [left, right]
-}

package/lib/AsyncResult.js

@@ -1,37 +0,0 @@
-// @flow
-
-type StatePending<T> = {status: "pending", promise: Promise<T>}
-type StateComplete<T> = {status: "complete", result: T}
-type StateFailure = {status: "failure", error: any}
-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 class AsyncResult<T> {
-	_state: AsyncResultState<T>
-
-	constructor(promise: Promise<T>) {
-		this._state = pending(promise)
-		promise
-			.then(result => this._state = complete(result))
-			.catch(error => this._state = failure(error))
-	}
-
-	state(): $ReadOnly<AsyncResultState<T>> {
-		return this._state
-	}
-}
-
-function pending<T>(promise: Promise<T>): StatePending<T> {
-	return {status: "pending", promise}
-}
-
-function complete<T>(result: T): StateComplete<T> {
-	return {status: "complete", result}
-}
-
-function failure(error: any): StateFailure {
-	return {status: "failure", error}
-}

package/lib/CollectionUtils.js

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

package/lib/DateUtils.js

@@ -1,134 +0,0 @@
-// @flow
-
-/**
- * @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 const DAY_IN_MILLIS = 1000 * 60 * 60 * 24
-
-/**
- * Provides a date representing the beginning of the next day of the given date in local time.
- */
-export function getStartOfNextDay(date: Date): Date {
-	let d = new Date(date.getTime())
-	d.setDate(date.getDate() + 1);
-	d.setHours(0, 0, 0, 0) // sets the beginning of the day in local time
-	return d
-}
-
-/**
- * Provides a date representing the end of the given date in local time.
- */
-export function getEndOfDay(date: Date): Date {
-	let d = new Date(date.getTime())
-	d.setHours(23, 59, 59, 999)
-	return d
-}
-
-/**
- * Provides a date representing the beginning of the given date in local time.
- */
-export function getStartOfDay(date: Date): Date {
-	return getHourOfDay(date, 0)
-}
-
-/**
- * Provides a date representing the day of the given date at the given hour in local time.
- */
-export function getHourOfDay(date: Date, hour: number): Date {
-	let d = new Date(date.getTime())
-	d.setHours(hour, 0, 0, 0)
-	return d
-}
-
-export function isStartOfDay(date: Date): boolean {
-	return date.getHours() === 0 && date.getMinutes() === 0
-}
-
-/**
- * Returns true if the given date is today in local time.
- */
-export function isToday(date: Date): boolean {
-	return new Date().toDateString() === date.toDateString()
-}
-
-/**
- * Returns true if the given dates represent the same day (time of day is ignored).
- */
-export function isSameDay(date1: Date, date2: Date): boolean {
-	return date1.toDateString() === date2.toDateString()
-}
-
-/**
- * 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 function getDayShifted(date: Date, days: number): Date {
-	return new Date(date.getTime() + days * DAY_IN_MILLIS)
-}
-
-/**
- * Increment the date in place and return it
- */
-export function incrementDate(date: Date, byValue: number): Date {
-	date.setDate(date.getDate() + byValue)
-	return date
-}
-
-export function incrementMonth(d: Date, byValue: number): Date {
-	const date = new Date(d)
-	date.setMonth(date.getMonth() + byValue)
-	return date
-}
-
-export function isSameDayOfDate(date1: ?Date, date2: ?Date): boolean {
-	return !date1 && !date2
-		|| date1 != null && date2 != null
-		&& date1.getFullYear() === date2.getFullYear()
-		&& date1.getMonth() === date2.getMonth()
-		&& date1.getDate() === date2.getDate()
-}
-
-
-/**
- * Formats as yyyy-mm-dd
- */
-export function formatSortableDate(date: Date): string {
-	const month = ("0" + (date.getMonth() + 1)).slice(-2)
-	const day = ("0" + date.getDate()).slice(-2)
-	return `${date.getFullYear()}-${month}-${day}`
-}
-
-/**
- * Formats as yyyy-mm-dd-<hh>h-<mm>m-<ss>
- */
-export function formatSortableDateTime(date: Date): string {
-	const hours = ("0" + date.getHours()).slice(-2)
-	const minutes = ("0" + date.getMinutes()).slice(-2)
-	const seconds = ("0" + date.getSeconds()).slice(-2)
-	return `${formatSortableDate(date)}-${hours}h${minutes}m${seconds}s`
-}
-
-/**
- * @returns {string} sortableDateTime of the current time
- */
-export function sortableTimestamp(): string {
-	return formatSortableDateTime(new Date())
-}
-
-export function isValidDate(date: Date): boolean {
-	return !isNaN(date.getTime())
-}
-
-/**
- * not interested in any fancy calendar edge cases, only use this where approximation is ok
- */
-export function millisToDays(millis: number): number {
-	return millis / DAY_IN_MILLIS
-}
-
-export function daysToMillis(days: number): number {
-	return days * DAY_IN_MILLIS
-}