@ezez/utils 4.5.0 → 4.7.0

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

@@ -4,8 +4,9 @@ type MatchCallback<T> = (value: T) => boolean;
  * A `Array.prototype.filter`-like function that splits the results into two groups - matched and unmatched
  * @param {Array} list - original array
  * @param {function} fn - function matching elements
+ * @deprecated - use `Map.groupBy` instead for even more robustness
  */
-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);
     });

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 @@
-{}