@ezez/utils 4.4.0 → 4.6.0

package/package.json

@@ -1,28 +1,9 @@
 {
   "name": "@ezez/utils",
-  "version": "4.4.0",
+  "version": "4.6.0",
   "repository": "https://github.com/dzek69/bottom-line.git",
   "author": "Jacek Nowacki @dzek69 <git-public@dzek.eu>",
   "license": "MIT",
-  "scripts": {
-    "test": "NODE_ENV=test jest",
-    "test:lodashImports": "node test/lodash-tree.cjs",
-    "docs": "typedoc src/index.ts --skipErrorChecking --out docs --includeVersion",
-    "compile": "pnpm run compile:esm && pnpm run compile:cjs",
-    "compile:esm": "rm -rf esm && tsc --project tsconfig.esm.json && node ./build-scripts/compile.esm.after.mjs",
-    "compile:cjs": "rm -rf dist && tsc --project tsconfig.cjs.json && node ./build-scripts/compile.cjs.after.mjs",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint src",
-    "lint:fix": "pnpm run lint --fix",
-    "prepack": "pnpm run compile",
-    "prepublishOnly": "pnpm run lint && pnpm run test && pnpm run docs",
-    "start:dev": "nodemon",
-    "start:dev:compatibility": "TS_NODE_FILES=true pnpm run start:dev",
-    "prepare": "husky install",
-    "updates": "pnpm dlx npm-check-updates --dep prod",
-    "updates:dev": "pnpm dlx npm-check-updates --dep dev",
-    "updates:all": "pnpm dlx npm-check-updates"
-  },
   "exports": {
     ".": {
       "require": "./dist/index.js",
@@ -35,25 +16,25 @@
   "module": "./esm/index.js",
   "type": "module",
   "devDependencies": {
-    "@babel/core": "^7.24.3",
-    "@babel/preset-env": "^7.24.3",
-    "@babel/preset-typescript": "^7.24.1",
-    "@ezez/eslint": "^0.0.6",
-    "@types/jest": "^29.5.5",
+    "@babel/core": "^7.26.0",
+    "@babel/preset-env": "^7.26.0",
+    "@babel/preset-typescript": "^7.26.0",
+    "@ezez/eslint": "^9.37.4",
+    "@types/jest": "^29.5.14",
     "@types/lodash": "^4.14.168",
     "@types/node": "^20.8.3",
     "babel-plugin-module-extension": "^0.1.3",
-    "fs-extra": "^11.1.1",
+    "fs-extra": "^11.3.0",
     "husky": "^8.0.3",
     "jest": "^29.7.0",
     "lodash": "^4.17.21",
     "must": "^0.13.4",
-    "nodemon": "^3.0.1",
-    "prettier": "^3.2.5",
-    "resolve-tspaths": "^0.8.15",
+    "nodemon": "^3.1.9",
+    "prettier": "^3.4.2",
+    "resolve-tspaths": "^0.8.23",
     "ts-node": "^10.9.2",
-    "typedoc": "^0.26.0-beta.1",
-    "typescript": "^5.4.5"
+    "typedoc": "0.27.6",
+    "typescript": "^5.7.3"
   },
   "husky": {
     "hooks": {
@@ -61,10 +42,26 @@
     }
   },
   "libraryTemplate": {
-    "version": "3.12.0",
+    "version": "3.14.0",
     "language": "typescript",
     "fixDefaultForCommonJS": false,
     "jsx": false
   },
-  "dependencies": {}
-}
+  "dependencies": {},
+  "scripts": {
+    "test": "NODE_ENV=test jest",
+    "test:lodashImports": "node test/lodash-tree.cjs",
+    "docs": "typedoc src/index.ts --skipErrorChecking --out docs --includeVersion",
+    "compile": "pnpm run compile:esm && pnpm run compile:cjs",
+    "compile:esm": "rm -rf esm && tsc --project tsconfig.esm.json && node ./build-scripts/compile.esm.after.mjs",
+    "compile:cjs": "rm -rf dist && tsc --project tsconfig.cjs.json && node ./build-scripts/compile.cjs.after.mjs",
+    "typecheck": "tsc --noEmit",
+    "lint": "ezlint src",
+    "lint:fix": "pnpm run lint --fix",
+    "start:dev": "nodemon",
+    "start:dev:compatibility": "TS_NODE_FILES=true pnpm run start:dev",
+    "updates": "pnpm dlx npm-check-updates --dep prod",
+    "updates:dev": "pnpm dlx npm-check-updates --dep dev",
+    "updates:all": "pnpm dlx npm-check-updates"
+  }
+}

package/src/cap.ts

@@ -4,7 +4,7 @@
  * @param {number} upperLimit - upper limit, inclusive
  * @param {number} [lowerLimit] - lower limit, inclusive
  */
-const cap = (value: number, upperLimit: number, lowerLimit?: number) => {
+const cap = (value: number, upperLimit: number, lowerLimit?: number): number => {
     if (lowerLimit == null) {
         return Math.min(value, upperLimit);
     }

package/src/capitalize.ts

@@ -1,12 +1,12 @@
 /**
  * Capitalize the first letter of a string.
- * @param {string} text - source string
- * @param {boolean} [restLowercase=false] - should the rest of the string be forced to lowercase?
+ * @param text - source string
+ * @param restLowercase - should the rest of the string be forced to lowercase?
  * @example capitalize("hello") // "Hello"
  * @example capitalize("hello my Friend", true) // "Hello my friend"
  * @example capitalize("hello my Friend", false) // "Hello my Friend"
  */
-const capitalize = (text: string, restLowercase = false) => {
+const capitalize = (text: string, restLowercase = false): string => {
     const rest = restLowercase ? text.slice(1).toLowerCase() : text.slice(1);
     return text.charAt(0).toUpperCase() + rest;
 };

package/src/compareArrays.ts

@@ -9,12 +9,11 @@ import { unique } from "./unique.js";
  * onlyB - items that exists only in second array,
  * both - items that exists in both arrays
  */
-const compareArrays = <T extends unknown[]>(arrayA: T, arrayB: T): { onlyA: T; onlyB: T; both: T } => {
+const compareArrays = <T>(arrayA: T[], arrayB: T[]): { onlyA: T[]; onlyB: T[]; both: T[] } => {
     const onlyA = unique(arrayA.filter((item) => !arrayB.includes(item)));
     const onlyB = unique(arrayB.filter((item) => !arrayA.includes(item)));
     const both = unique(arrayA.filter((item) => arrayB.includes(item)));
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return { onlyA, onlyB, both } as { onlyA: T; onlyB: T; both: T };
+    return { onlyA, onlyB, both };
 };
 
 export {

package/src/deserialize.spec.ts

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

package/src/deserialize.ts

@@ -69,6 +69,6 @@ const deserialize = <T>(serializedString: string, customDeserializers?: CustomDe
     return hasUndefined ? replaceDeep(parsed, UNDEFINED, undefined) : parsed;
 };
 
-export { deserialize };
+export { deserialize, deserialize as unserialize };
 
 export type { CustomDeserializers };

package/src/ensureError.ts

@@ -10,11 +10,15 @@
  * @param {*} e - value to check
  * @returns Error - original error or new Error instance
  */
-const ensureError = (e: unknown) => {
+const ensureError = (e: unknown): Error => {
     if (e instanceof Error) {
         return e;
     }
-    return new Error("Expected error instance, got something else: " + String(e));
+
+    // eslint-disable-next-line @typescript-eslint/no-base-to-string
+    return new Error("Expected error instance, got something else: " + String(e), {
+        cause: e,
+    });
 };
 
 export {

package/src/ensurePrefix.ts

@@ -6,7 +6,7 @@
  * @param {string} string - string to add prefix to
  * @param {string} prefix - prefix to add
  */
-const ensurePrefix = (string: string, prefix: string) => {
+const ensurePrefix = (string: string, prefix: string): string => {
     if (string.startsWith(prefix)) {
         return string;
     }

package/src/ensureSuffix.ts

@@ -6,7 +6,7 @@
  * @param {string} string - string to add suffix to
  * @param {string} suffix - suffix to add
  */
-const ensureSuffix = (string: string, suffix: string) => {
+const ensureSuffix = (string: string, suffix: string): string => {
     if (string.endsWith(suffix)) {
         return string;
     }

package/src/escapeRegExp.ts

@@ -9,7 +9,7 @@
  * regex.test(badName); // true
  * ```
  */
-const escapeRegExp = (string: string) => {
+const escapeRegExp = (string: string): string => {
     return string.replace(/[/\-\\^$*+?.()|[\]{}]/gu, "\\$&");
 };
 

package/src/formatDate.ts

@@ -8,10 +8,15 @@ import { ensureDate } from "./ensureDate.js";
  *
  * Important: this is work in progress. All locale-based values are not supported yet. Formats that heavily depend on
  * locale won't ever be supported.
+ *
+ * @example
+ * ```typescript
+ * formatDate(Date.now(), "%Y-%m-%d %H:%M:%S"); // ie: "2024-06-26 14:23:45"
+ * ```
  */
 const formatDate = (date: Date | number, format: string, locale = "en-US"): string => { // eslint-disable-line max-lines-per-function
     const d = ensureDate(date);
-    return format.replace(/%([%a-zA-Z])/gu, (_, c) => {
+    return format.replace(/%([%a-zA-Z])/gu, (_, c: string) => {
         switch (c) {
             case "%": return "%";
             // Day
@@ -64,7 +69,7 @@ const formatDate = (date: Date | number, format: string, locale = "en-US"): stri
             case "n": return "\n";
             case "t": return "\t";
         }
-        return c as string;
+        return c;
     });
 };
 

package/src/get.spec.ts

@@ -54,7 +54,6 @@ describe("get", () => {
 
     it("doesn't parse string as js code, behaves NOT like lodash", () => {
         // Lodash intention-guessing example, inconsistency detected
-        // eslint-disable-next-line @typescript-eslint/no-shadow
         const name = get(testObject, "product[name]");
         (name === undefined).must.be.true();
 

package/src/getMultiple.ts

@@ -29,7 +29,6 @@ const DEFAULT = {};
  * @returns {*} - found value or default value
  */
 const getMultiple = (source: Source, defaultValue: unknown, ...paths: (string | string[])[]): unknown => {
-    // eslint-disable-next-line @typescript-eslint/no-shadow
     const length = paths.length;
     for (let i = 0; i < length; i++) {
         const properties = paths[i]!;

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

@@ -1,4 +1,6 @@
 /* eslint-disable import/max-dependencies */
+export * from "./serializeToBuffer/serializeToBuffer.js";
+export * from "./serializeToBuffer/unserializeFromBuffer.js";
 export * from "./ensurePrefix.js";
 export * from "./ensureSuffix.js";
 export * from "./cap.js";
@@ -15,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;
     }
 }