@naturalcycles/js-lib 14.96.0 → 14.96.1

package/dist/error/try.d.ts

@@ -10,20 +10,26 @@ import { AppError } from './app.error';
  * For convenience, second argument type is non-optional,
  * so you can use it without `!`. But you SHOULD always check `if (err)` first!
  *
+ * ERR is typed as Error, not `unknown`. While unknown would be more correct,
+ * according to recent TypeScript, Error gives more developer convenience.
+ * In our code we NEVER throw non-errors.
+ * Only possibility of non-error is in the 3rd-party library code, in these cases it
+ * can be manually cast to `unknown` for extra safety.
+ *
  * @example
  *
  * const [err, v] = _try(() => someFunction())
  * if (err) ...do something...
  * v // go ahead and use v
  */
-export declare function _try<ERR = unknown, RETURN = void>(fn: () => RETURN): [err: ERR | null, value: RETURN];
+export declare function _try<ERR = Error, RETURN = void>(fn: () => RETURN): [err: ERR | null, value: RETURN];
 /**
  * Like _try, but for Promises.
  *
  * Also, intentionally types second return item as non-optional,
  * but you should check for `err` presense first!
  */
-export declare function pTry<ERR = unknown, RETURN = void>(promise: Promise<RETURN>): Promise<[err: ERR | null, value: Awaited<RETURN>]>;
+export declare function pTry<ERR = Error, RETURN = void>(promise: Promise<RETURN>): Promise<[err: ERR | null, value: Awaited<RETURN>]>;
 /**
  * It is thrown when Error was expected, but didn't happen
  * ("pass" happened instead).

package/dist/error/try.js

@@ -12,6 +12,12 @@ const app_error_1 = require("./app.error");
  * For convenience, second argument type is non-optional,
  * so you can use it without `!`. But you SHOULD always check `if (err)` first!
  *
+ * ERR is typed as Error, not `unknown`. While unknown would be more correct,
+ * according to recent TypeScript, Error gives more developer convenience.
+ * In our code we NEVER throw non-errors.
+ * Only possibility of non-error is in the 3rd-party library code, in these cases it
+ * can be manually cast to `unknown` for extra safety.
+ *
  * @example
  *
  * const [err, v] = _try(() => someFunction())
@@ -49,7 +55,7 @@ exports.pTry = pTry;
  */
 class UnexpectedPassError extends app_error_1.AppError {
     constructor() {
-        super('_expectedError passed unexpectedly');
+        super('expected error was not thrown');
     }
 }
 exports.UnexpectedPassError = UnexpectedPassError;

package/dist/error/tryCatch.d.ts

@@ -5,7 +5,7 @@ export interface TryCatchOptions {
      * The value returned from the function will be returned from the wrapped method (!).
      * onError function may be asynchronous.
      */
-    onError?: (err: unknown) => any;
+    onError?: (err: Error) => any;
     /**
      * @default false
      */

package/dist/error/tryCatch.js

@@ -30,7 +30,7 @@ function _tryCatch(fn, opt = {}) {
             }
             if (onError) {
                 try {
-                    return await onError(err); // eslint-disable-line @typescript-eslint/return-await
+                    return await onError((0, index_1._anyToError)(err)); // eslint-disable-line @typescript-eslint/return-await
                 }
                 catch { }
             }

package/dist-esm/error/try.js

@@ -9,6 +9,12 @@ import { AppError } from './app.error';
  * For convenience, second argument type is non-optional,
  * so you can use it without `!`. But you SHOULD always check `if (err)` first!
  *
+ * ERR is typed as Error, not `unknown`. While unknown would be more correct,
+ * according to recent TypeScript, Error gives more developer convenience.
+ * In our code we NEVER throw non-errors.
+ * Only possibility of non-error is in the 3rd-party library code, in these cases it
+ * can be manually cast to `unknown` for extra safety.
+ *
  * @example
  *
  * const [err, v] = _try(() => someFunction())
@@ -44,7 +50,7 @@ export async function pTry(promise) {
  */
 export class UnexpectedPassError extends AppError {
     constructor() {
-        super('_expectedError passed unexpectedly');
+        super('expected error was not thrown');
     }
 }
 /**

package/dist-esm/error/tryCatch.js

@@ -1,4 +1,4 @@
-import { _since, _stringifyAny } from '../index';
+import { _anyToError, _since, _stringifyAny } from '../index';
 /**
  * Decorates a function with "try/catch", so it'll never reject/throw.
  * Only applies to async functions (or, turns sync function into async).
@@ -27,7 +27,7 @@ export function _tryCatch(fn, opt = {}) {
             }
             if (onError) {
                 try {
-                    return await onError(err); // eslint-disable-line @typescript-eslint/return-await
+                    return await onError(_anyToError(err)); // eslint-disable-line @typescript-eslint/return-await
                 }
                 catch (_a) { }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.96.0",
+  "version": "14.96.1",
   "scripts": {
     "prepare": "husky install",
     "build-prod": "build-prod-esm-cjs",

package/src/error/try.ts

@@ -11,13 +11,19 @@ import { AppError } from './app.error'
  * For convenience, second argument type is non-optional,
  * so you can use it without `!`. But you SHOULD always check `if (err)` first!
  *
+ * ERR is typed as Error, not `unknown`. While unknown would be more correct,
+ * according to recent TypeScript, Error gives more developer convenience.
+ * In our code we NEVER throw non-errors.
+ * Only possibility of non-error is in the 3rd-party library code, in these cases it
+ * can be manually cast to `unknown` for extra safety.
+ *
  * @example
  *
  * const [err, v] = _try(() => someFunction())
  * if (err) ...do something...
  * v // go ahead and use v
  */
-export function _try<ERR = unknown, RETURN = void>(
+export function _try<ERR = Error, RETURN = void>(
   fn: () => RETURN,
 ): [err: ERR | null, value: RETURN] {
   try {
@@ -33,7 +39,7 @@ export function _try<ERR = unknown, RETURN = void>(
  * Also, intentionally types second return item as non-optional,
  * but you should check for `err` presense first!
  */
-export async function pTry<ERR = unknown, RETURN = void>(
+export async function pTry<ERR = Error, RETURN = void>(
   promise: Promise<RETURN>,
 ): Promise<[err: ERR | null, value: Awaited<RETURN>]> {
   try {
@@ -50,7 +56,7 @@ export async function pTry<ERR = unknown, RETURN = void>(
  */
 export class UnexpectedPassError extends AppError {
   constructor() {
-    super('_expectedError passed unexpectedly')
+    super('expected error was not thrown')
   }
 }
 

package/src/error/tryCatch.ts

@@ -1,4 +1,4 @@
-import { _since, _stringifyAny, CommonLogger } from '../index'
+import { _anyToError, _since, _stringifyAny, CommonLogger } from '../index'
 import { AnyFunction } from '../types'
 
 export interface TryCatchOptions {
@@ -6,7 +6,7 @@ export interface TryCatchOptions {
    * The value returned from the function will be returned from the wrapped method (!).
    * onError function may be asynchronous.
    */
-  onError?: (err: unknown) => any
+  onError?: (err: Error) => any
 
   /**
    * @default false
@@ -59,7 +59,7 @@ export function _tryCatch<T extends AnyFunction>(fn: T, opt: TryCatchOptions = {
 
       if (onError) {
         try {
-          return await onError(err) // eslint-disable-line @typescript-eslint/return-await
+          return await onError(_anyToError(err)) // eslint-disable-line @typescript-eslint/return-await
         } catch {}
       }
       // returns undefined, but doesn't rethrow