@ezez/utils 4.5.0 → 4.6.0

package/src/ignore.spec.ts

@@ -0,0 +1,80 @@
+// eslint-disable-next-line @typescript-eslint/no-shadow
+import must from "must";
+
+// @ts-ignore
+import createSpy from "../test/createSpy";
+import { ignore } from "./ignore";
+import { wait } from "./wait";
+
+const syncCrashingFunction = createSpy(() => {
+    throw new Error("Sync function crashed");
+});
+
+const promiseTypedSyncCrashingFunction = createSpy((): Promise<void> => {
+    throw new Error("Promise typed sync function crashed");
+});
+
+const asyncCrashingFunction = createSpy(async () => {
+    throw new Error("Async function crashed");
+});
+
+const asyncCrashingFunctionSlow = createSpy(async () => {
+    await wait(500);
+    throw new Error("Async function crashed");
+});
+
+const get5 = createSpy(() => 5);
+
+describe("ignore", () => {
+    beforeEach(() => {
+        syncCrashingFunction.__spy.reset();
+        promiseTypedSyncCrashingFunction.__spy.reset();
+        asyncCrashingFunction.__spy.reset();
+        asyncCrashingFunctionSlow.__spy.reset();
+        get5.__spy.reset();
+    });
+
+    it("it should not crash on sync function crash", async () => {
+        ignore(syncCrashingFunction);
+        ignore(promiseTypedSyncCrashingFunction);
+        // ^ technically this is also a sync crash
+    });
+
+    it("it should not crash on async function crash", async () => {
+        ignore(asyncCrashingFunction);
+    });
+
+    it("it should not wait for async function", async () => {
+        const now = Date.now();
+        ignore(asyncCrashingFunctionSlow);
+        const after = Date.now();
+        if (after - now > 100) {
+            throw new Error("Took too long, it waited for the async function");
+        }
+    });
+
+    it("should not return a value", async () => {
+        // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
+        const res = ignore(get5);
+        must(res).be.undefined();
+    });
+
+    it("actually calls the function", async () => {
+        must(syncCrashingFunction.__spy.calls.length).be.equal(0);
+        must(promiseTypedSyncCrashingFunction.__spy.calls.length).be.equal(0);
+        must(asyncCrashingFunction.__spy.calls.length).be.equal(0);
+        must(get5.__spy.calls.length).be.equal(0);
+
+        ignore(syncCrashingFunction);
+        must(syncCrashingFunction.__spy.calls.length).be.equal(1);
+
+        ignore(promiseTypedSyncCrashingFunction);
+        must(promiseTypedSyncCrashingFunction.__spy.calls.length).be.equal(1);
+
+        ignore(asyncCrashingFunction);
+        must(asyncCrashingFunction.__spy.calls.length).be.equal(1);
+
+        ignore(get5);
+        must(get5.__spy.calls.length).be.equal(1);
+    });
+});

package/src/ignore.ts

@@ -0,0 +1,38 @@
+/**
+ * A function that executes a callback and ignores it completely, if it throws an error, returns any value, rejects
+ * a promise - it will be all ignored. It will attach a catch handler to any returned promise to avoid unhandled
+ * rejections.
+ *
+ * Use it whenever you want to call a function, but you are not interested in its result or failure.
+ *
+ * @example
+ * ```javascript
+ * import { trackPageVisit } from "analytics-service";
+ *
+ * function onButtonClick() {
+ *     ignore(() => trackPageVisit("button-click"));
+ *     // ^ prevent uncaught errors or unhandled promise rejections from trackPageVisit
+ * }
+ * Promise.resolve(5).then(ignore(trackPageVisit)).then((value) => {
+ *   console.log(value); // 5, won't ever crash due to errors in trackPageVisit
+ * });
+ * ```
+ * @param callback
+ */
+const ignore = (callback: () => unknown): undefined => {
+    try {
+        // eslint-disable-next-line callback-return
+        const p = callback();
+        if (p && typeof p === "object"
+            && "then" in p && typeof p.then === "function"
+            && "catch" in p && typeof p.catch === "function") {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+            p.catch(() => null);
+        }
+    }
+    catch {}
+};
+
+export {
+    ignore,
+};

package/src/index.ts

@@ -17,6 +17,7 @@ export * from "./escapeRegExp.js";
 export * from "./formatDate.js";
 export * from "./get.js";
 export * from "./getMultiple.js";
+export * from "./ignore.js";
 export * from "./insertSeparator.js";
 export * from "./isEmpty.js";
 export * from "./isNumericString.js";

package/src/isEmpty.ts

@@ -1,11 +1,3 @@
-interface ObjectWithLength {
-    length: number;
-}
-
-interface ObjectWithSize {
-    size: number;
-}
-
 /**
  * Returns true if passed argument seems to be empty.
  * Nil values are empty.
@@ -15,7 +7,7 @@ interface ObjectWithSize {
  * Arrays and array-like objects are considered empty when length value is 0.
  * Map, Set and -like objects are considered empty when size value is 0.
  *
- * @param {*} obj - source value
+ * @param obj - source value
  * @example isEmpty({}) // true
  * @example isEmpty(100) // throws
  * @example isEmpty([]) // true
@@ -23,9 +15,11 @@ interface ObjectWithSize {
  * @example isEmpty({ length: 5 }) // false
  * @example isEmpty({ length: 0 }) // true
  * @example isEmpty({ size: 0 }) // true
- * @returns {boolean} - is value considered empty
+ * @returns is value considered empty
+ *
+ * @deprecated This function is not needed in a modern, type-safe code and is encouraging bad practices in general.
  */
-const isEmpty = (obj: unknown) => {
+const isEmpty = (obj: unknown): boolean => {
     if (typeof obj === "string") {
         return !obj.length;
     }
@@ -38,11 +32,11 @@ const isEmpty = (obj: unknown) => {
     if (Array.isArray(obj)) {
         return !Object.keys(obj).length;
     }
-    if ("length" in obj) {
-        return !(obj as ObjectWithLength).length;
+    if ("length" in obj && typeof obj.length === "number") {
+        return !(obj).length;
     }
-    if ("size" in obj) {
-        return !(obj as ObjectWithSize).size;
+    if ("size" in obj && typeof obj.size === "number") {
+        return !(obj).size;
     }
     return !Object.keys(obj).length;
 };

package/src/isNumericString.ts

@@ -17,7 +17,7 @@ const NOT_FOUND = -1;
  * @param {boolean} [options.allowInfinity=false] - Allow Infinity and -Infinity (casing matters)
  * @param {boolean} [options.allowNaN=false] - Allow NaN (casing matters)
  */
-const isNumericString = (string: string, options: Options = {}) => { // eslint-disable-line max-statements, max-lines-per-function
+const isNumericString = (string: string, options: Options = {}): boolean => { // eslint-disable-line max-statements, max-lines-per-function
     if (typeof string !== "string") {
         throw new TypeError("Expected a string");
     }

package/src/isPlainObject.ts

@@ -7,7 +7,7 @@
  * @example isPlainObject(5); // returns false
  * @param value - value to test
  */
-const isPlainObject = (value: unknown) => Boolean(
+const isPlainObject = (value: unknown): boolean => Boolean(
     value
     && typeof value === "object"
     && (

package/src/later.spec.ts

@@ -28,6 +28,7 @@ describe("later", () => {
         const l = later();
         l.reject(new Error("foo"));
 
+        // eslint-disable-next-line @typescript-eslint/await-thenable
         await l.promise.must.reject.with.error("foo");
     });
 });

package/src/mapAsync.ts

@@ -7,10 +7,10 @@ const DEFAULT_WAIT_TIME = 1;
  * Non-blocking version of `Array.prototype.map`, it will pause the map loop every `pauseEvery`. Keep in mind that
  * depending on your code workload the pause interval and duration may be exact or longer than specified. It's the same
  * single thread JavaScript nature setTimeout have to follow.
- * @param {Array} context - original array
- * @param {function} callback - map function
- * @param {number} pauseEvery - pause after this many ms
- * @param {number} pauseTime - how long to wait on pause
+ * @param context - original array
+ * @param callback - map function
+ * @param pauseEvery - pause after this many ms
+ * @param pauseTime - how long to wait on pause
  */
 const mapAsync = async <T, Y>(
     context: readonly T[],

package/src/match.ts

@@ -5,7 +5,7 @@ type MatchCallback<T> = (value: T) => boolean;
  * @param {Array} list - original array
  * @param {function} fn - function matching elements
  */
-const match = <T>(list: T[], fn: MatchCallback<T>) => {
+const match = <T>(list: T[], fn: MatchCallback<T>): { matched: T[]; unmatched: T[] } => {
     const matched: T[] = [];
     const unmatched: T[] = [];
     list.forEach(item => {

package/src/memoize.spec.ts

@@ -1,8 +1,8 @@
 // eslint-disable-next-line @typescript-eslint/no-shadow
 import must from "must";
 
+// @ts-ignore
 import createSpy from "../test/createSpy";
-
 import { memoize } from "./memoize";
 
 describe("memoize", () => {

package/src/memoize.ts

@@ -10,7 +10,7 @@
  * @param fn - function to memoize
  * @returns memoized function
  */
-const memoize = <Args extends unknown[], Ret>(fn: (...args: Args) => Ret) => {
+const memoize = <Args extends unknown[], Ret>(fn: (...args: Args) => Ret): (this: unknown, ...args: Args) => Ret => {
     let lastArgs: Args | undefined, lastResult: Ret, lastThis: unknown;
 
     return function memoized(this: unknown, ...args: Args): Ret {

package/src/mostFrequent.spec.ts

@@ -1,3 +1,5 @@
+import must from "must"; // eslint-disable-line @typescript-eslint/no-shadow
+
 import { mostFrequent } from "./mostFrequent.js";
 
 describe("mostFrequent", () => {

package/src/mostFrequent.ts

@@ -3,7 +3,6 @@
  * @param {Array} array
  */
 const mostFrequent = <T>(array: T[]): T => {
-    // eslint-disable-next-line @typescript-eslint/no-shadow
     let top = 0,
         topValue = array[0];
 

package/src/noop.ts

@@ -1,7 +1,7 @@
 /**
  * No-operation function. It does nothing and returns nothing.
  */
-const noop = () => undefined;
+const noop = (): undefined => undefined;
 
 export {
     noop,

package/src/occurrences.ts

@@ -18,7 +18,7 @@ const NOT_FOUND = -1;
  * @param {object} [options] - options
  * @param {boolean} [options.overlap=false] - allow overlapping matches, ie "aa" in "aaa" will return 2 instead of 1
  */
-const occurrences = (string: string, search: string, { overlap }: Options = {}) => {
+const occurrences = (string: string, search: string, { overlap }: Options = {}): number => {
     if (typeof string !== "string") {
         throw new TypeError("Expected a string");
     }

package/src/remove.spec.ts

@@ -1,7 +1,7 @@
 import { remove as _remove } from "lodash";
 
+// @ts-ignore
 import createSpy from "../test/createSpy.js";
-
 import { remove } from "./remove.js";
 
 describe("remove", () => {

package/src/removeCommonProperties.spec.ts

@@ -1,3 +1,5 @@
+import must from "must"; // eslint-disable-line @typescript-eslint/no-shadow
+
 import { removeCommonProperties } from "./removeCommonProperties.js";
 
 describe("removeCommonProperties", () => {

package/src/removeCommonProperties.ts

@@ -22,7 +22,7 @@ type Obj = Record<string, unknown>;
  * @example removeCommonProperties({ title: "Hello", author: "John"}, { title: "Hello 2", author: "John" }, { title: "Hello 3", author: "Matt" });
  * // targets: { title: "Hello 2", author: "John" }, { title: "Hello 3", author: "Matt" }
  */
-const removeCommonProperties = (source: Obj, target1: Obj, ...targetN: Obj[]) => {
+const removeCommonProperties = (source: Obj, target1: Obj, ...targetN: Obj[]): void => {
     const targets = [target1, ...targetN];
     const keys = Object.keys(source);
     for (const key of keys) {

package/src/replace.ts

@@ -7,7 +7,7 @@ import { escapeRegExp } from "./escapeRegExp.js";
  * @example replace("Hello, %name%!", { "%name%: "John" }) // "Hello, John!"
  * @example replace("Hello, %name%! Nice to meet you %name%!", { "%name%": "Jane" }) // "Hello, Jane! Nice to meet you Jane!"
  */
-const replace = (source: string, replaceMap: Record<string, string>) => {
+const replace = (source: string, replaceMap: Record<string, string>): string => {
     const keys = Object.keys(replaceMap);
     if (keys.length === 0) {
         return source;

package/src/replaceDeep.spec.ts

@@ -1,3 +1,5 @@
+import must from "must"; // eslint-disable-line @typescript-eslint/no-shadow
+
 import { replaceDeep } from "./replaceDeep";
 
 class MyClass {

package/src/replaceDeepByFn.spec.ts

@@ -1,3 +1,5 @@
+import must from "must"; // eslint-disable-line @typescript-eslint/no-shadow
+
 import { replaceDeepByFn } from "./replaceDeepByFn";
 
 class MyClass {

package/src/rethrow.ts

@@ -2,7 +2,7 @@
  * Throws given value.
  * @param {*} e
  */
-const rethrow = (e: unknown) => {
+const rethrow = (e: unknown): void => {
     // eslint-disable-next-line @typescript-eslint/only-throw-error
     throw e;
 };

package/src/round.ts

@@ -10,7 +10,7 @@
  * @param value - value to round
  * @param precision - precision to round to
  */
-const round = (value: number, precision?: number) => {
+const round = (value: number, precision?: number): number => {
     // eslint-disable-next-line @typescript-eslint/no-magic-numbers
     const multiplier = Math.pow(10, precision || 0);
     return Math.round(value * multiplier) / multiplier;

package/src/safe.ts

@@ -10,11 +10,12 @@ function safe<T, Y>(fn: () => T, def: Y): T | Y;
  * safe(() => JSON.parse(unknownString), null); // if unknownString is not a valid JSON, null will be returned
  * safe(() => trySomethingComplicated(), defaultValue); // if trySomethingComplicated throws, defaultValue will be returned
  */
-function safe<T, Y>(fn: () => T, def?: Y) { // eslint-disable-line func-style
+function safe<T, Y>(fn: () => T, def?: Y): T | (Y extends undefined ? undefined : Y) {
     try {
         return fn();
     }
     catch {
+        // @ts-ignore ts can't do conditional returns in runtime
         return def;
     }
 }

package/src/scale.ts

@@ -9,7 +9,7 @@
  * @param {number} toMax
  * @param {number} number
  */
-const scale = (fromMin: number, fromMax: number, toMin: number, toMax: number, number: number) => {
+const scale = (fromMin: number, fromMax: number, toMin: number, toMax: number, number: number): number => {
     return toMin + ((number - fromMin) / (fromMax - fromMin) * (toMax - toMin));
 };
 

package/src/seq.ts

@@ -48,7 +48,11 @@ const run = <T>(list: Fn<T>[], earlyBreaker?: EarlyBreaker): Promise<T> => {
             }
             const fn = promises.shift();
             if (typeof fn !== "function") {
-                const finalError = new Error("Every function had thrown.");
+                const finalError = new Error("Every function had thrown.", {
+                    cause: {
+                        errors,
+                    },
+                });
                 // @ts-expect-error More details on error object are wanted
                 finalError.details = { errors };
                 reject(finalError);
@@ -73,7 +77,7 @@ const run = <T>(list: Fn<T>[], earlyBreaker?: EarlyBreaker): Promise<T> => {
  * arguments with array
  * @returns {*} - whatever gets returned from given functions
  */
-const seqEarlyBreak = <T>(earlyBreaker: EarlyBreaker | undefined, ...args: Functions<T>) => {
+const seqEarlyBreak = <T>(earlyBreaker: EarlyBreaker | undefined, ...args: Functions<T>): Promise<T> => {
     if (args.length === 1) {
         return run(Array.isArray(args[0]) ? args[0] : [args[0]], earlyBreaker);
     }
@@ -91,7 +95,7 @@ const seqEarlyBreak = <T>(earlyBreaker: EarlyBreaker | undefined, ...args: Funct
  * arguments with array
  * @returns {*} - whatever gets returned from given functions
  */
-const seq = <T>(...fns: Functions<T>) => {
+const seq = <T>(...fns: Functions<T>): Promise<T> => {
     return seqEarlyBreak(undefined, ...fns);
 };
 

package/src/serialize.spec.ts

@@ -1,3 +1,5 @@
+import must from "must"; // eslint-disable-line @typescript-eslint/no-shadow
+
 import type { CustomSerializers } from "./serialize";
 
 import { serialize } from "./serialize";
@@ -9,7 +11,6 @@ interface Test {
 class Person {
     public name: string;
 
-    // eslint-disable-next-line @typescript-eslint/no-shadow
     public constructor(name: string) {
         this.name = name;
     }

package/src/serialize.ts

@@ -1,6 +1,6 @@
-import { sortProps } from "./sortProps.js";
-import { replaceDeepByFn } from "./replaceDeepByFn.js";
 import { isPlainObject } from "./isPlainObject.js";
+import { replaceDeepByFn } from "./replaceDeepByFn.js";
+import { sortProps } from "./sortProps.js";
 import { DataWrapper } from "./utils/utils.js";
 
 type CustomSerializers = {
@@ -34,7 +34,7 @@ type Options = {
  * @param customSerializers - an object with custom serializers
  * @param options - options
  */
-const serialize = (data: unknown, customSerializers?: CustomSerializers, options?: Options) => { // eslint-disable-line max-lines-per-function
+const serialize = (data: unknown, customSerializers?: CustomSerializers, options?: Options): string => { // eslint-disable-line max-lines-per-function
     const sourceData = Object.keys(customSerializers ?? {}).length
         ? replaceDeepByFn(
             data,

package/src/serializeToBuffer/serialization.spec.ts

@@ -1,7 +1,7 @@
 import must from "must"; // eslint-disable-line @typescript-eslint/no-shadow
 
-import { unserializeFromBuffer } from "./unserializeFromBuffer";
 import { serializeToBuffer } from "./serializeToBuffer";
+import { unserializeFromBuffer } from "./unserializeFromBuffer";
 
 const serialize = serializeToBuffer.bind(null, Buffer, []);
 const unserialize = unserializeFromBuffer.bind(null, Buffer, []);
@@ -41,7 +41,7 @@ describe("serialization", () => {
     });
 
     it("serializes JSON-looking string", async () => {
-        const data = [`"TEST"`];
+        const data = ["\"TEST\""];
         must(unserialize(serialize(...data))).eql(data);
     });
 

package/src/serializeToBuffer/serializeToBuffer.ts

@@ -1,5 +1,4 @@
 import { serialize } from "../serialize.js";
-
 import { BINARY_MARK_BIN, BINARY_MARK_JSON, BINARY_MARK_STRING } from "./const.js";
 
 type SerializeArgs = Parameters<typeof serialize> extends [any, ...infer Rest] ? Rest : never; // eslint-disable-line @typescript-eslint/no-explicit-any

package/src/serializeToBuffer/unserializeFromBuffer.ts

@@ -1,5 +1,4 @@
 import { deserialize } from "../deserialize.js";
-
 import { BINARY_MARK_BIN, BINARY_MARK_MAP, BINARY_MARK_STRING } from "./const.js";
 
 const MAX_DATA_PARTS = 4;

package/src/setImmutable.ts

@@ -9,7 +9,7 @@ const isObject = (value: unknown) => (typeof value === "object" || typeof value
 
 const clone = (value: unknown[] | Source) => {
     if (Array.isArray(value)) {
-        return [...value as never as unknown[]]; // typecasts to satisfy eslint
+        return [...value];
     }
     return { ...value };
 };

package/src/sortBy.ts

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-magic-numbers */
+
 import { sortByMultiple } from "./sortByMultiple.js";
 
 /**
@@ -10,7 +12,7 @@ import { sortByMultiple } from "./sortByMultiple.js";
  */
 const sortBy = <T extends Record<string | number | symbol, any>>( // eslint-disable-line @typescript-eslint/no-explicit-any
     propertyName: keyof T, asc = true, defaultValue: unknown = null,
-) => (a: T, b: T) => {
+) => (a: T, b: T): -1 | 0 | 1 => {
     // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any
     return sortByMultiple([propertyName], asc, { [propertyName]: defaultValue } as Partial<Record<keyof T, any>>)(a, b);
 };

package/src/sortByMultiple.ts

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-magic-numbers */
+
 /**
  * Returns a function that can be used as a callback to `.sort()` method. Returned function will sort array by given
  * properties.
@@ -34,12 +36,12 @@ const sortByMultiple = <
     ascending: boolean | Record<K[number], boolean> = true,
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     defaultValues?: Partial<Record<K[number], any>>, // Force defaultValues to use only keys from K
-): ((a: T, b: T) => number) => (a: T, b: T) => {
+): ((a: T, b: T) => 1 | -1 | 0) => (a: T, b: T): 1 | -1 | 0 => {
     for (const propertyName of propertyNames) {
         // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         const asc = typeof ascending === "boolean" ? ascending : (ascending[propertyName] ?? true);
-        const aBiggerValue = asc ? 1 : -1; // eslint-disable-line @typescript-eslint/no-magic-numbers
-        const bBiggerValue = asc ? -1 : 1; // eslint-disable-line @typescript-eslint/no-magic-numbers
+        const aBiggerValue = asc ? 1 : -1;
+        const bBiggerValue = asc ? -1 : 1;
 
         const aValue = a[propertyName] ?? defaultValues?.[propertyName];
         const bValue = b[propertyName] ?? defaultValues?.[propertyName];

package/src/toggle.spec.ts

@@ -1,3 +1,5 @@
+import must from "must"; // eslint-disable-line @typescript-eslint/no-shadow
+
 import { toggle } from "./toggle.js";
 
 describe("toggle", () => {

package/src/trim.spec.ts

@@ -1,3 +1,5 @@
+import must from "must"; // eslint-disable-line @typescript-eslint/no-shadow
+
 import { trim } from "./trim";
 
 describe("trim", () => {

package/src/trim.ts

@@ -1,5 +1,5 @@
-import { trimStart } from "./trimStart.js";
 import { trimEnd } from "./trimEnd.js";
+import { trimStart } from "./trimStart.js";
 
 /**
  * Removes given characters from both sides of the string.
@@ -14,10 +14,11 @@ import { trimEnd } from "./trimEnd.js";
  * trim("!aaa!!!", "!"); // "aaa"
  * trim("!aaa!!!", "!!!"); // "!aaa"
  */
-const trim = (source: string, characters: string) => {
+const trim = (source: string, characters: string): string => {
     return trimStart(trimEnd(source, characters), characters);
 };
 
 export {
     trim,
 };
+

package/src/trimEnd.spec.ts

@@ -1,3 +1,5 @@
+import must from "must"; // eslint-disable-line @typescript-eslint/no-shadow
+
 import { trimEnd } from "./trimEnd";
 
 describe("trimEnd", () => {

package/src/trimEnd.ts

@@ -9,7 +9,7 @@
  * trimEnd("abcxzyz", "yz"); // "abcxz"
  * trimEnd("!aaa!!", "!"); // "!aaa"
  */
-const trimEnd = (source: string, characters: string) => {
+const trimEnd = (source: string, characters: string): string => {
     let s = source;
     while (s.endsWith(characters)) {
         s = s.slice(0, -characters.length);

package/src/trimStart.spec.ts

@@ -1,3 +1,5 @@
+import must from "must"; // eslint-disable-line @typescript-eslint/no-shadow
+
 import { trimStart } from "./trimStart";
 
 describe("trimStart", () => {

package/src/trimStart.ts

@@ -9,7 +9,7 @@
  * trimStart("abbcb", "ab"); // "bcb"
  * trimStart("!!aaa!", "!"); // "aaa!"
  */
-const trimStart = (source: string, characters: string) => {
+const trimStart = (source: string, characters: string): string => {
     let s = source;
     while (s.startsWith(characters)) {
         s = s.slice(characters.length);

package/src/unique.ts

@@ -3,8 +3,8 @@
  * @param arr - source array
  * @example unique([1, 2, 3, 2, 1]) // [1, 2, 3]
  */
-const unique = <T extends unknown[]>(arr: T): T => {
-    return [...new Set(arr)] as T;
+const unique = <T>(arr: T[]): T[] => {
+    return [...new Set(arr)];
 };
 
 export {

package/src/wait.ts

@@ -3,7 +3,7 @@
  * @param {number} timeMs - time to wait
  * @returns {Promise<void>}
  */
-const wait = (timeMs = 0) => {
+const wait = (timeMs = 0): Promise<void> => {
     return new Promise<void>((resolve) => {
         setTimeout(() => { resolve(); }, timeMs);
     });