@ezez/utils 4.4.0 → 4.6.0

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 = {
@@ -23,8 +23,7 @@ type Options = {
  *
  * It also supports custom serializers, which can be used to serialize custom data types. Each value has a prefix which
  * specifies the type of the value, custom serializers is a map of these prefixes to functions which can serialize the
- * value into a string. IMPORTANT: Because this is using JSON.serialize under the hood if a value to serialize includes
- * `toJSON` it won't trigger custom serializer but will be serialized as string. `Date` class defines `toJSON` method!
+ * value into a string.
  *
  * The extra aim of this function is to produce the same output for "the same" data, regardless of the order of the keys
  * (which is not guaranteed by JS spec, but in practice it is guaranteed by current implementations of all JS engines),
@@ -35,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/const.ts

@@ -0,0 +1,16 @@
+const BINARY_MARK_BIN = "t";
+const BINARY_MARK_STRING = "f";
+const BINARY_MARK_JSON = "j";
+
+const BINARY_MARK_MAP = {
+    [BINARY_MARK_BIN]: "binary",
+    [BINARY_MARK_STRING]: "string",
+    [BINARY_MARK_JSON]: "json",
+};
+
+export {
+    BINARY_MARK_BIN,
+    BINARY_MARK_STRING,
+    BINARY_MARK_JSON,
+    BINARY_MARK_MAP,
+};

package/src/serializeToBuffer/serialization.spec.ts

@@ -0,0 +1,61 @@
+import must from "must"; // eslint-disable-line @typescript-eslint/no-shadow
+
+import { serializeToBuffer } from "./serializeToBuffer";
+import { unserializeFromBuffer } from "./unserializeFromBuffer";
+
+const serialize = serializeToBuffer.bind(null, Buffer, []);
+const unserialize = unserializeFromBuffer.bind(null, Buffer, []);
+
+describe("serialization", () => {
+    it("serializes basic string", async () => {
+        const data = ["TEST"];
+        must(unserialize(serialize(...data))).eql(data);
+    });
+
+    it("serializes json", async () => {
+        const data = [
+            { a: 1, b: 2 },
+        ];
+        must(unserialize(serialize(...data))).eql(data);
+    });
+
+    it("serializes multiple data", async () => {
+        const data = [
+            "hey",
+            3,
+            { a: 1 },
+            Buffer.from("test"),
+        ];
+        const result = unserialize(serialize(...data));
+        const buffer = result.pop() as Buffer;
+        must(result).eql(data.slice(0, 3));
+        must(buffer).be.instanceof(Buffer);
+        must(buffer.toString()).equal("test");
+    });
+
+    it("serializes undefined", async () => {
+        const data = [undefined];
+        const result = unserialize(serialize(...data));
+        must(result).have.length(1);
+        must(result[0]).be.undefined();
+    });
+
+    it("serializes JSON-looking string", async () => {
+        const data = ["\"TEST\""];
+        must(unserialize(serialize(...data))).eql(data);
+    });
+
+    it("serializes huge object", async () => {
+        const data = [{
+            a: 1,
+            b: false,
+            c: true,
+            d: "test",
+            e: null,
+            f: undefined,
+            g: [1, 2, 3],
+            h: { a: 1, b: [2] },
+        }];
+        must(unserialize(serialize(...data))).eql(data);
+    });
+});

package/src/serializeToBuffer/serializeToBuffer.spec.ts

@@ -0,0 +1,43 @@
+import must from "must"; // eslint-disable-line @typescript-eslint/no-shadow
+
+import { serializeToBuffer } from "./serializeToBuffer";
+
+const serialize = serializeToBuffer.bind(null, Buffer, []);
+
+describe("serialize", () => {
+    it("serializes basic string", async () => {
+        // len 4, type string, data "test", separator
+        must(serialize("test").toString("hex")).equal("3466007465737400");
+    });
+
+    it("serializes multiple strings", async () => {
+        // len 4, type string, data "test", separator
+        must(serialize("test", "test").toString("hex")).equal("34660074657374003466007465737400");
+    });
+
+    it("serializes basic buffer", async () => {
+        // len 4, type bin, data "test", separator
+        must(serialize(Buffer.from("test")).toString("hex")).equal("3474007465737400");
+    });
+
+    it("serializes both buffer and string", async () => {
+        // len 4, type bin, data "test", separator, len 4, bin false, data "test", separator
+        must(serialize(Buffer.from("test"), "test").toString("hex")).equal("34740074657374003466007465737400");
+    });
+
+    it("serializes JSON-looking string", async () => {
+        // len 6, type string, data "test", separator
+        must(serialize(`"test"`).toString("hex")).equal("36660022746573742200");
+    });
+
+    it("serializes JSON-serialized string", async () => {
+        // len 8, type string, data "test", separator
+        must(serialize(`"s:test"`).toString("hex")).equal("38660022733a746573742200");
+    });
+
+    it("serializes number", async () => {
+        // len 5, type json, data "n:1", separator
+        must(serialize(1).toString("hex")).equal("356a00226e3a312200");
+    });
+    // TODO more tests
+});

package/src/serializeToBuffer/serializeToBuffer.ts

@@ -0,0 +1,89 @@
+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
+
+/**
+ * Serialize any data to a Buffer, useful when working with web sockets or other binary protocols.
+ * Make sure to understand how {@link serialize} works before using this function.
+ *
+ * To make this function work in browsers it accepts a BufferImplementation parameter.
+ * To make the serialization customizable it accepts a serializeArgs parameter.
+ * It's therefore recommended to first prepare the function with bind, like:
+ * @example
+ * ```ts
+ * import { serializeToBuffer as serializeRaw } from "@ezez/utils";
+ * import { Buffer } from "buffer/"; // skip import in Node.js
+ *
+ * // prepare the function:
+ * const serializeToBuffer = serializeRaw.bind(null, Buffer, []); // array is customization params for serialize
+ *
+ * const serialized = serializeToBuffer("test", 1, { test: "test" });
+ * ```
+ *
+ * Otherwise pass the params each time:
+ * ```typescript
+ * import { serializeToBuffer as serializeRaw } from "@ezez/utils";
+ * const serialized = serializeToBuffer(Buffer, [], "test", 1, { test: "test" });
+ * const otherSerialized = serializeToBuffer(Buffer, [], any, other, data);
+ * ```
+ * @param BufferImplementation - Buffer implementation, in browsers use `buffer` npm package
+ * and import it from `buffer/`, in Node.js simply pass `Buffer`.
+ * @param serializeArgs - [customSerializers, options] - optional arguments if you need to serialize custom data types,
+ * see: {@link serialize}
+ * @param args - any data to serialize, can be a Buffer, string or any other data type
+ * @returns Buffer - serialized data
+ */
+const serializeToBuffer = (
+    BufferImplementation: typeof Buffer, serializeArgs: SerializeArgs, ...args: unknown[]
+): Buffer => {
+    const separator = BufferImplementation.from([0x0]);
+    type DataType = {
+        mark: typeof BINARY_MARK_BIN;
+        data: Buffer;
+    } | {
+        mark: typeof BINARY_MARK_STRING;
+        data: string;
+    } | {
+        mark: typeof BINARY_MARK_JSON;
+        data: unknown;
+    };
+
+    const convertedArgs = args.map((arg) => {
+        if (arg instanceof BufferImplementation) {
+            return {
+                mark: BINARY_MARK_BIN,
+                data: arg,
+            } satisfies DataType;
+        }
+        if (typeof arg === "string") {
+            return {
+                mark: BINARY_MARK_STRING,
+                data: arg,
+            } satisfies DataType;
+        }
+        return {
+            mark: BINARY_MARK_JSON,
+            data: serialize(arg, ...serializeArgs),
+        } satisfies DataType;
+    });
+    const dataToSend: Buffer[] = [];
+    let totalLength = 0;
+    convertedArgs.forEach((arg) => {
+        const len = String(arg.data.length) + arg.mark;
+
+        dataToSend.push(BufferImplementation.from(len, "utf-8"));
+        dataToSend.push(separator);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        dataToSend.push(arg.mark === BINARY_MARK_BIN ? arg.data : BufferImplementation.from(arg.data, "utf-8"));
+        dataToSend.push(separator);
+
+        totalLength += len.length + separator.length + arg.data.length + separator.length;
+    });
+
+    return BufferImplementation.concat(dataToSend, totalLength);
+};
+
+export {
+    serializeToBuffer,
+};

package/src/serializeToBuffer/unserializeFromBuffer.spec.ts

@@ -0,0 +1,63 @@
+import must from "must"; // eslint-disable-line @typescript-eslint/no-shadow
+
+import { unserializeFromBuffer } from "./unserializeFromBuffer";
+
+const unserialize = unserializeFromBuffer.bind(null, Buffer, []);
+
+describe("unserialize", () => {
+    it("unserializes basic string", async () => {
+        must(unserialize(Buffer.from([0x34, 0x66, 0x00, 0x74, 0x65, 0x73, 0x74, 0x00]))).eql(["test"]);
+    });
+
+    it("unserializes multiple strings", async () => {
+        must(unserialize(Buffer.from([
+            0x34, 0x66, 0x00, 0x74, 0x65, 0x73, 0x74, 0x00,
+            0x34, 0x66, 0x00, 0x74, 0x65, 0x73, 0x74, 0x00,
+        ]))).eql(["test", "test"]);
+    });
+
+    it("unserializes buffer", async () => {
+        const result = unserialize(Buffer.from([0x34, 0x74, 0x00, 0x74, 0x65, 0x73, 0x74, 0x00]));
+        must(result.length).equal(1);
+        must(result[0]).instanceof(Buffer);
+        must((result[0] as Buffer).toString()).equal("test");
+    });
+
+    it("unserializes both buffer and string", async () => {
+        const result = unserialize(Buffer.from([
+            0x34, 0x74, 0x00, 0x74, 0x65, 0x73, 0x74, 0x00,
+            0x34, 0x66, 0x00, 0x74, 0x65, 0x73, 0x74, 0x00,
+        ]));
+
+        must(result.length).equal(2);
+
+        must(result[0]).instanceof(Buffer);
+        must((result[0] as Buffer).toString()).equal("test");
+
+        must(result[1]).equal("test");
+    });
+
+    it("unserializes JSON-looking string as string", async () => {
+        must(unserialize(
+            Buffer.from([0x36, 0x66, 0x00, 0x22, 0x74, 0x65, 0x73, 0x74, 0x22, 0x00]),
+        )).eql([`"test"`]);
+    });
+
+    it("unserializes JSON-serialized string as string", async () => {
+        must(unserialize(Buffer.from([
+            0x38, 0x66, 0x00, 0x22, 0x73, 0x3a, 0x74, 0x65, 0x73, 0x74, 0x22, 0x00,
+        ]))).eql([`"s:test"`]);
+    });
+
+    it("unserializes JSON-serialized json as string", async () => {
+        must(unserialize(Buffer.from([
+            0x38, 0x6a, 0x00, 0x22, 0x73, 0x3a, 0x74, 0x65, 0x73, 0x74, 0x22, 0x00,
+        ]))).eql(["test"]);
+    });
+
+    it("unserializes number as number", async () => {
+        must(unserialize(Buffer.from([
+            0x35, 0x6a, 0x00, 0x22, 0x6e, 0x3a, 0x31, 0x22, 0x00,
+        ]))).eql([1]);
+    });
+});

package/src/serializeToBuffer/unserializeFromBuffer.ts

@@ -0,0 +1,74 @@
+import { deserialize } from "../deserialize.js";
+import { BINARY_MARK_BIN, BINARY_MARK_MAP, BINARY_MARK_STRING } from "./const.js";
+
+const MAX_DATA_PARTS = 4;
+
+const NOT_FOUND = -1;
+const LAST_CHAR = -1;
+
+type DeserializeArgs = Parameters<typeof deserialize> extends [any, ...infer Rest] ? Rest : never; // eslint-disable-line @typescript-eslint/no-explicit-any
+
+/**
+ * Unserialize data from a Buffer serialized with {@link serializeToBuffer}, useful when working with web sockets or
+ * other binary protocols. Make sure to understand how {@link deserialize} works before using this function.
+ * @param BufferImplementation - Buffer implementation, in browsers use `buffer` npm package
+ * and import it from `buffer/`, in Node.js simply pass `Buffer`.
+ * @param deserializeArgs - [customDeserializers] - optional arguments if you need to unserialize custom data types,
+ * @param rawData - Buffer to unserialize
+ * @returns unserialized data
+ */
+const unserializeFromBuffer = <RT extends any[] = unknown[]>( // eslint-disable-line @typescript-eslint/no-explicit-any,max-statements
+    BufferImplementation: typeof Buffer, deserializeArgs: DeserializeArgs, rawData: Buffer | Uint8Array,
+): RT => {
+    const intData: Uint8Array = rawData instanceof Uint8Array ? rawData : new Uint8Array(rawData);
+
+    if (intData.length === 0) {
+        throw new Error("No data to unserialize");
+    }
+
+    let startPoint = 0;
+    const result = [];
+
+    let i = 0;
+    while (i++ < MAX_DATA_PARTS) {
+        const dataSplitPoint = intData.indexOf(0, startPoint); // find null
+        if (dataSplitPoint === NOT_FOUND) { // no null found = no data
+            break;
+        }
+
+        const lengthBytes = BufferImplementation.from(intData.slice(startPoint, dataSplitPoint)).toString("utf8");
+        const binaryMark = lengthBytes.slice(LAST_CHAR) as keyof typeof BINARY_MARK_MAP;
+        if (!Object.keys(BINARY_MARK_MAP).includes(binaryMark)) {
+            throw new Error(`Invalid binary mark: ${binaryMark}`);
+        }
+
+        const len = Number(lengthBytes.slice(0, lengthBytes.length - 1));
+
+        const dataStringFrom = dataSplitPoint + 1;
+        const dataStringTo = dataStringFrom + len;
+        const dataBytes = intData.slice(dataStringFrom, dataStringTo);
+
+        if (binaryMark === BINARY_MARK_BIN) {
+            result.push(dataBytes);
+        }
+        else if (binaryMark === BINARY_MARK_STRING) {
+            const stringData = BufferImplementation.from(dataBytes).toString("utf8");
+            result.push(stringData);
+        }
+        else {
+            const stringData = BufferImplementation.from(dataBytes).toString("utf8");
+            const jsonData = deserialize(stringData, ...deserializeArgs);
+            result.push(jsonData);
+        }
+
+        startPoint = dataStringTo + 1; // skip separating null
+    }
+
+    if (result.length === 0) {
+        throw new Error("No data found (no split points)");
+    }
+
+    return result as RT;
+};
+
+export { unserializeFromBuffer, unserializeFromBuffer as deserializeFromBuffer };

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);
     });

package/src/waitFor.spec.ts

@@ -1,10 +1,10 @@
 // eslint-disable-next-line @typescript-eslint/no-shadow
 import must from "must";
 
+// @ts-ignore
 import createSpy from "../test/createSpy";
-
-import { waitFor } from "./waitFor";
 import { wait } from "./wait";
+import { waitFor } from "./waitFor";
 
 describe("waitFor", () => {
     it("calls function multiple times until it returns truthy value", async () => {
@@ -91,12 +91,13 @@ describe("waitFor", () => {
 
     it("crashes if check function crashes", async () => {
         await waitFor(() => {
+            // @ts-ignore
             throw new Error(5);
-        }, 40).then(() => {
+        }, { interval: 40 }).then(() => {
             throw new Error("Should not resolve");
-        }, (e) => {
+        }, (e: unknown) => {
             must(e).instanceOf(Error);
-            must(e.message).equal("[waitFor] check function threw an error");
+            must((e as Error).message).equal("[waitFor] check function threw an error");
         });
     });
 
@@ -134,11 +135,11 @@ describe("waitFor", () => {
         it("by crashing if check function returns rejected promise", async () => {
             await waitFor(() => {
                 return Promise.reject(new Error("oops"));
-            }, 40).then(() => {
+            }, { interval: 40 }).then(() => {
                 throw new Error("Should not resolve");
-            }, (e) => {
+            }, (e: unknown) => {
                 must(e).instanceOf(Error);
-                must(e.message).equal("[waitFor] check function threw an error");
+                must((e as Error).message).equal("[waitFor] check function threw an error");
             });
         });
     });

package/src/waitFor.ts

@@ -39,7 +39,7 @@ const defaultOptions: Required<Options> = {
  * @param fn - callback function
  * @param options - options object
  */
-const waitFor = <T>(fn: () => MaybePromise<T>, options: Options = defaultOptions) => {
+const waitFor = <T>(fn: () => MaybePromise<T>, options: Options = defaultOptions): Promise<T> => {
     return new Promise<T>((resolve, reject) => {
         let intervalTimer: TTimeout, failTimer: TTimeout;
 

package/src/waitSync.spec.ts

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

package/src/waitSync.ts

@@ -3,7 +3,7 @@
  * @param {number} timeMs - time to wait
  * @returns {Promise<void>}
  */
-const waitSync = (timeMs = 0) => {
+const waitSync = (timeMs = 0): void => {
     const s = Date.now();
     // eslint-disable-next-line no-empty
     while (Date.now() - s < timeMs) {}

package/.prettierignore

@@ -1,3 +0,0 @@
-*.js
-*.ts
-*.tsx

package/.prettierrc.json

@@ -1 +0,0 @@
-{}