@naturalcycles/js-lib 14.157.0 → 14.158.0

package/dist/error/assert.d.ts

@@ -33,6 +33,12 @@ export declare function _assertEquals<T>(actual: any, expected: T, message?: str
  */
 export declare function _assertDeepEquals<T>(actual: any, expected: T, message?: string, errorData?: ErrorData): asserts actual is T;
 export declare function _assertIsError<ERR extends Error = Error>(err: any, errorClass?: Class<ERR>): asserts err is ERR;
+/**
+ * Asserts that passed object is indeed an Error of defined ErrorClass.
+ * If yes - returns peacefully (with TypeScript assertion).
+ * In not - throws (re-throws) that error up.
+ */
+export declare function _assertErrorClassOrRethrow<ERR extends Error>(err: any, errorClass: Class<ERR>): asserts err is ERR;
 export declare function _assertIsErrorObject<DATA_TYPE extends ErrorData = ErrorData>(obj: any): asserts obj is ErrorObject<DATA_TYPE>;
 export declare function _assertIsString(v: any, message?: string): asserts v is string;
 export declare function _assertIsNumber(v: any, message?: string): asserts v is number;

package/dist/error/assert.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AssertionError = exports._assertTypeOf = exports._assertIsNumber = exports._assertIsString = exports._assertIsErrorObject = exports._assertIsError = exports._assertDeepEquals = exports._assertEquals = exports._assert = void 0;
+exports.AssertionError = exports._assertTypeOf = exports._assertIsNumber = exports._assertIsString = exports._assertIsErrorObject = exports._assertErrorClassOrRethrow = exports._assertIsError = exports._assertDeepEquals = exports._assertEquals = exports._assert = void 0;
 const __1 = require("..");
 const app_error_1 = require("./app.error");
 /**
@@ -84,6 +84,18 @@ function _assertIsError(err, errorClass = Error) {
     }
 }
 exports._assertIsError = _assertIsError;
+/**
+ * Asserts that passed object is indeed an Error of defined ErrorClass.
+ * If yes - returns peacefully (with TypeScript assertion).
+ * In not - throws (re-throws) that error up.
+ */
+function _assertErrorClassOrRethrow(err, errorClass) {
+    if (!(err instanceof errorClass)) {
+        // re-throw
+        throw err;
+    }
+}
+exports._assertErrorClassOrRethrow = _assertErrorClassOrRethrow;
 function _assertIsErrorObject(obj) {
     if (!(0, __1._isErrorObject)(obj)) {
         const msg = [`expected to be ErrorObject`, `actual typeof: ${typeof obj}`].join('\n');

package/dist/error/httpRequestError.d.ts

@@ -18,5 +18,11 @@ import type { ErrorObject, HttpRequestErrorData } from './error.model';
  * (by default).
  */
 export declare class HttpRequestError extends AppError<HttpRequestErrorData> {
-    constructor(message: string, data: HttpRequestErrorData, cause?: ErrorObject);
+    constructor(message: string, data: HttpRequestErrorData, cause: ErrorObject);
+    /**
+     * Cause is strictly-defined for HttpRequestError,
+     * so it always has a cause.
+     * (for dev convenience)
+     */
+    cause: ErrorObject;
 }

package/dist/error/try.d.ts

@@ -1,5 +1,5 @@
 import type { Class } from '../typeFest';
-import type { AnyFunction } from '../types';
+import type { AnyFunction, ErrorDataTuple } from '../types';
 import { AppError } from './app.error';
 /**
  * Calls a function, returns a Tuple of [error, value].
@@ -8,9 +8,6 @@ import { AppError } from './app.error';
  *
  * Similar to pTry, but for sync functions.
  *
- * 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.
@@ -23,14 +20,11 @@ import { AppError } from './app.error';
  * if (err) ...do something...
  * v // go ahead and use v
  */
-export declare function _try<ERR = Error, RETURN = void>(fn: () => RETURN): [err: ERR | null, value: RETURN];
+export declare function _try<T, ERR extends Error = Error>(fn: () => T, errorClass?: Class<ERR>): ErrorDataTuple<T, ERR>;
 /**
  * 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 = Error, RETURN = void>(promise: Promise<RETURN>): Promise<[err: ERR | null, value: Awaited<RETURN>]>;
+export declare function pTry<T, ERR extends Error = Error>(promise: Promise<T>, errorClass?: Class<ERR>): Promise<ErrorDataTuple<Awaited<T>, ERR>>;
 /**
  * It is thrown when Error was expected, but didn't happen
  * ("pass" happened instead).
@@ -61,3 +55,7 @@ export declare function pExpectedError<ERR = Error>(promise: Promise<any>, error
  * Shortcut function to simplify error snapshot-matching in tests.
  */
 export declare function pExpectedErrorString<ERR = Error>(promise: Promise<any>, errorClass?: Class<ERR>): Promise<string>;
+/**
+ * Shortcut function to simplify error snapshot-matching in tests.
+ */
+export declare function _expectedErrorString<ERR = Error>(fn: AnyFunction, errorClass?: Class<ERR>): string;

package/dist/error/try.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pExpectedErrorString = exports.pExpectedError = exports._expectedError = exports.UnexpectedPassError = exports.pTry = exports._try = void 0;
+exports._expectedErrorString = exports.pExpectedErrorString = exports.pExpectedError = exports._expectedError = exports.UnexpectedPassError = exports.pTry = exports._try = void 0;
 const stringifyAny_1 = require("../string/stringifyAny");
 const app_error_1 = require("./app.error");
+const assert_1 = require("./assert");
 /**
  * Calls a function, returns a Tuple of [error, value].
  * Allows to write shorter code that avoids `try/catch`.
@@ -10,9 +11,6 @@ const app_error_1 = require("./app.error");
  *
  * Similar to pTry, but for sync functions.
  *
- * 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.
@@ -25,27 +23,30 @@ const app_error_1 = require("./app.error");
  * if (err) ...do something...
  * v // go ahead and use v
  */
-function _try(fn) {
+function _try(fn, errorClass) {
     try {
         return [null, fn()];
     }
     catch (err) {
-        return [err, undefined];
+        if (errorClass) {
+            (0, assert_1._assertErrorClassOrRethrow)(err, errorClass);
+        }
+        return [err, null];
     }
 }
 exports._try = _try;
 /**
  * Like _try, but for Promises.
- *
- * Also, intentionally types second return item as non-optional,
- * but you should check for `err` presense first!
  */
-async function pTry(promise) {
+async function pTry(promise, errorClass) {
     try {
         return [null, await promise];
     }
     catch (err) {
-        return [err, undefined];
+        if (errorClass) {
+            (0, assert_1._assertErrorClassOrRethrow)(err, errorClass);
+        }
+        return [err, null];
     }
 }
 exports.pTry = pTry;
@@ -114,6 +115,15 @@ exports.pExpectedError = pExpectedError;
  * Shortcut function to simplify error snapshot-matching in tests.
  */
 async function pExpectedErrorString(promise, errorClass) {
-    return (0, stringifyAny_1._stringifyAny)(await pExpectedError(promise, errorClass));
+    const err = await pExpectedError(promise, errorClass);
+    return (0, stringifyAny_1._stringifyAny)(err);
 }
 exports.pExpectedErrorString = pExpectedErrorString;
+/**
+ * Shortcut function to simplify error snapshot-matching in tests.
+ */
+function _expectedErrorString(fn, errorClass) {
+    const err = _expectedError(fn, errorClass);
+    return (0, stringifyAny_1._stringifyAny)(err);
+}
+exports._expectedErrorString = _expectedErrorString;

package/dist/http/fetcher.d.ts

@@ -1,6 +1,17 @@
 /// <reference lib="dom" />
 /// <reference lib="dom.iterable" />
-import type { FetcherAfterResponseHook, FetcherBeforeRequestHook, FetcherBeforeRetryHook, FetcherCfg, FetcherNormalizedCfg, FetcherOptions, FetcherResponse } from './fetcher.model';
+import { HttpRequestError } from '../error/httpRequestError';
+import { ErrorDataTuple } from '../types';
+import type { FetcherAfterResponseHook, FetcherBeforeRequestHook, FetcherBeforeRetryHook, FetcherCfg, FetcherNormalizedCfg, FetcherOptions, FetcherResponse, FetcherMockFunction, RequestInitNormalized } from './fetcher.model';
+/**
+ * Allows to mock Fetcher.callNativeFetch globally (for all Fetcher instances out there).
+ *
+ * Call it with `null` to reset/unmock.
+ *
+ * Please note that jest.spyOn(someFetcher, 'callNativeFetch') has higher priority than
+ * a global mock, so it'll run instead of a global mock.
+ */
+export declare function setGlobalFetcherMock(fn: FetcherMockFunction | null): void;
 /**
  * Experimental wrapper around Fetch.
  * Works in both Browser and Node, using `globalThis.fetch`.
@@ -39,17 +50,27 @@ export declare class Fetcher {
      */
     getReadableStream(url: string, opt?: FetcherOptions): Promise<ReadableStream<Uint8Array>>;
     fetch<T = unknown>(opt: FetcherOptions): Promise<T>;
+    /**
+     * Like pTry - returns a [err, data] tuple (aka ErrorDataTuple).
+     * err, if defined, is strictly HttpRequestError.
+     * UPD: actually not, err is typed as Error, as it feels unsafe to guarantee error type.
+     * UPD: actually yes - it will return HttpRequestError, and throw if there's an error
+     * of any other type.
+     */
+    tryFetch<T = unknown>(opt: FetcherOptions): Promise<ErrorDataTuple<T, HttpRequestError>>;
     /**
      * Returns FetcherResponse.
      * Never throws, returns `err` property in the response instead.
      * Use this method instead of `throwHttpErrors: false` or try-catching.
+     *
+     * Note: responseType defaults to `void`, so, override it if you expect different.
      */
     doFetch<T = unknown>(opt: FetcherOptions): Promise<FetcherResponse<T>>;
     private onOkResponse;
     /**
      * This method exists to be able to easily mock it.
      */
-    callNativeFetch(url: string, init: RequestInit): Promise<Response>;
+    callNativeFetch(url: string, init: RequestInitNormalized): Promise<Response>;
     private onNotOkResponse;
     private processRetry;
     private getRetryTimeout;

package/dist/http/fetcher.js

@@ -2,8 +2,9 @@
 /// <reference lib="dom"/>
 /// <reference lib="dom.iterable"/>
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFetcher = exports.Fetcher = void 0;
+exports.getFetcher = exports.Fetcher = exports.setGlobalFetcherMock = void 0;
 const env_1 = require("../env");
+const assert_1 = require("../error/assert");
 const error_util_1 = require("../error/error.util");
 const httpRequestError_1 = require("../error/httpRequestError");
 const number_util_1 = require("../number/number.util");
@@ -28,6 +29,19 @@ const defRetryOptions = {
     timeoutMax: 30000,
     timeoutMultiplier: 2,
 };
+let globalFetcherMock = null;
+/**
+ * Allows to mock Fetcher.callNativeFetch globally (for all Fetcher instances out there).
+ *
+ * Call it with `null` to reset/unmock.
+ *
+ * Please note that jest.spyOn(someFetcher, 'callNativeFetch') has higher priority than
+ * a global mock, so it'll run instead of a global mock.
+ */
+function setGlobalFetcherMock(fn) {
+    globalFetcherMock = fn;
+}
+exports.setGlobalFetcherMock = setGlobalFetcherMock;
 /**
  * Experimental wrapper around Fetch.
  * Works in both Browser and Node, using `globalThis.fetch`.
@@ -112,28 +126,32 @@ class Fetcher {
         }
         return res.body;
     }
+    /**
+     * Like pTry - returns a [err, data] tuple (aka ErrorDataTuple).
+     * err, if defined, is strictly HttpRequestError.
+     * UPD: actually not, err is typed as Error, as it feels unsafe to guarantee error type.
+     * UPD: actually yes - it will return HttpRequestError, and throw if there's an error
+     * of any other type.
+     */
+    async tryFetch(opt) {
+        const res = await this.doFetch(opt);
+        if (res.err) {
+            (0, assert_1._assertErrorClassOrRethrow)(res.err, httpRequestError_1.HttpRequestError);
+            return [res.err, null];
+        }
+        return [null, res.body];
+    }
     /**
      * Returns FetcherResponse.
      * Never throws, returns `err` property in the response instead.
      * Use this method instead of `throwHttpErrors: false` or try-catching.
+     *
+     * Note: responseType defaults to `void`, so, override it if you expect different.
      */
     async doFetch(opt) {
         const req = this.normalizeOptions(opt);
         const { logger } = this.cfg;
         const { timeoutSeconds, init: { method }, } = req;
-        // setup timeout
-        let timeout;
-        if (timeoutSeconds) {
-            const abortController = new AbortController();
-            req.init.signal = abortController.signal;
-            timeout = setTimeout(() => {
-                // Apparently, providing a `string` reason to abort() causes Undici to throw `invalid_argument` error,
-                // so, we're wrapping it in a TimeoutError instance
-                abortController.abort(new pTimeout_1.TimeoutError(`request timed out after ${timeoutSeconds} sec`));
-                // abortController.abort(`timeout of ${timeoutSeconds} sec`)
-                // abortController.abort()
-            }, timeoutSeconds * 1000);
-        }
         for (const hook of this.cfg.hooks.beforeRequest || []) {
             await hook(req);
         }
@@ -152,6 +170,18 @@ class Fetcher {
         };
         while (!res.retryStatus.retryStopped) {
             req.started = Date.now();
+            // setup timeout
+            let timeoutId;
+            if (timeoutSeconds) {
+                const abortController = new AbortController();
+                req.init.signal = abortController.signal;
+                timeoutId = setTimeout(() => {
+                    // console.log(`actual request timed out in ${_since(req.started)}`)
+                    // Apparently, providing a `string` reason to abort() causes Undici to throw `invalid_argument` error,
+                    // so, we're wrapping it in a TimeoutError instance
+                    abortController.abort(new pTimeout_1.TimeoutError(`request timed out after ${timeoutSeconds} sec`));
+                }, timeoutSeconds * 1000);
+            }
             if (this.cfg.logRequest) {
                 const { retryAttempt } = res.retryStatus;
                 logger.log([' >>', signature, retryAttempt && `try#${retryAttempt + 1}/${req.retry.count + 1}`]
@@ -175,14 +205,30 @@ class Fetcher {
                 // important to set it to undefined, otherwise it can keep the previous value (from previous try)
                 res.fetchResponse = undefined;
             }
+            finally {
+                clearTimeout(timeoutId);
+                // Separate Timeout will be introduced to "download and parse the body"
+            }
             res.statusFamily = this.getStatusFamily(res);
             res.statusCode = res.fetchResponse?.status;
             if (res.fetchResponse?.ok) {
-                await this.onOkResponse(res, timeout);
+                try {
+                    // We are applying a separate Timeout (as long as original Timeout for now) to "download and parse the body"
+                    await (0, pTimeout_1.pTimeout)(async () => await this.onOkResponse(res), {
+                        timeout: timeoutSeconds * 1000 || Number.POSITIVE_INFINITY,
+                        name: 'Fetcher.onOkResponse',
+                    });
+                }
+                catch (err) {
+                    // onOkResponse can still fail, e.g when loading/parsing json, text or doing other response manipulation
+                    res.err = (0, error_util_1._anyToError)(err);
+                    res.ok = false;
+                    await this.onNotOkResponse(res);
+                }
             }
             else {
                 // !res.ok
-                await this.onNotOkResponse(res, timeout);
+                await this.onNotOkResponse(res);
             }
         }
         for (const hook of this.cfg.hooks.afterResponse || []) {
@@ -190,31 +236,17 @@ class Fetcher {
         }
         return res;
     }
-    async onOkResponse(res, timeout) {
+    async onOkResponse(res) {
         const { req } = res;
         const { responseType } = res.req;
+        // This function is subject to a separate timeout to "download and parse the data"
         if (responseType === 'json') {
             if (res.fetchResponse.body) {
                 const text = await res.fetchResponse.text();
                 if (text) {
-                    try {
-                        res.body = text;
-                        res.body = (0, json_util_1._jsonParse)(text, req.jsonReviver);
-                    }
-                    catch (err) {
-                        // Error while parsing json
-                        // res.err = _anyToError(err, HttpRequestError, {
-                        //   requestUrl: res.req.url,
-                        //   requestBaseUrl: this.cfg.baseUrl,
-                        //   requestMethod: res.req.init.method,
-                        //   requestSignature: res.signature,
-                        //   requestDuration: Date.now() - started,
-                        //   responseStatusCode: res.fetchResponse.status,
-                        // } satisfies HttpRequestErrorData)
-                        res.err = (0, error_util_1._anyToError)(err);
-                        res.ok = false;
-                        return await this.onNotOkResponse(res, timeout);
-                    }
+                    res.body = text;
+                    res.body = (0, json_util_1._jsonParse)(text, req.jsonReviver);
+                    // Error while parsing json can happen - it'll be handled upstream
                 }
                 else {
                     // Body had a '' (empty string)
@@ -239,12 +271,10 @@ class Fetcher {
         else if (responseType === 'readableStream') {
             res.body = res.fetchResponse.body;
             if (res.body === null) {
-                res.err = new Error(`fetchResponse.body is null`);
-                res.ok = false;
-                return await this.onNotOkResponse(res, timeout);
+                // Error is to be handled upstream
+                throw new Error(`fetchResponse.body is null`);
             }
         }
-        clearTimeout(timeout);
         res.retryStatus.retryStopped = true;
         // res.err can happen on `failed to fetch` type of error, e.g JSON.parse, CORS, unexpected redirect
         if (!res.err && this.cfg.logResponse) {
@@ -268,10 +298,13 @@ class Fetcher {
      * This method exists to be able to easily mock it.
      */
     async callNativeFetch(url, init) {
+        // If global mock is defined - call it instead of the native Fetch
+        if (globalFetcherMock) {
+            return await globalFetcherMock(url, init);
+        }
         return await globalThis.fetch(url, init);
     }
-    async onNotOkResponse(res, timeout) {
-        clearTimeout(timeout);
+    async onNotOkResponse(res) {
         let cause;
         if (res.err) {
             // This is only possible on JSON.parse error, or CORS error,
@@ -285,6 +318,11 @@ class Fetcher {
                 cause = (0, error_util_1._anyToErrorObject)(body);
             }
         }
+        cause ||= {
+            name: 'Error',
+            message: 'Fetch failed',
+            data: {},
+        };
         const message = [res.fetchResponse?.status, res.signature].filter(Boolean).join(' ');
         res.err = new httpRequestError_1.HttpRequestError(message, (0, object_util_1._filterNullishValues)({
             responseStatusCode: res.fetchResponse?.status || 0,
@@ -337,7 +375,11 @@ class Fetcher {
             return;
         retryStatus.retryAttempt++;
         retryStatus.retryTimeout = (0, number_util_1._clamp)(retryStatus.retryTimeout * timeoutMultiplier, 0, timeoutMax);
-        await (0, pDelay_1.pDelay)(this.getRetryTimeout(res));
+        const timeout = this.getRetryTimeout(res);
+        if (res.req.debug) {
+            this.cfg.logger.log(` .. ${res.signature} waiting ${(0, time_util_1._ms)(timeout)}`);
+        }
+        await (0, pDelay_1.pDelay)(timeout);
     }
     getRetryTimeout(res) {
         let timeout = 0;
@@ -392,8 +434,9 @@ class Fetcher {
         if (statusFamily === 3 && !retry3xx)
             return false;
         // should not retry on `unexpected redirect` in error.cause.cause
-        if (res.err?.cause?.cause?.message?.includes('unexpected redirect'))
+        if (res.err?.cause?.cause?.message?.includes('unexpected redirect')) {
             return false;
+        }
         return true; // default is true
     }
     getStatusFamily(res) {
@@ -431,14 +474,14 @@ class Fetcher {
     }
     normalizeCfg(cfg) {
         if (cfg.baseUrl?.endsWith('/')) {
-            console.warn(`Fetcher: baseUrl should not end with /`);
+            console.warn(`Fetcher: baseUrl should not end with slash: ${cfg.baseUrl}`);
             cfg.baseUrl = cfg.baseUrl.slice(0, cfg.baseUrl.length - 1);
         }
         const { debug = false } = cfg;
         const norm = (0, object_util_1._merge)({
             baseUrl: '',
             inputUrl: '',
-            responseType: 'void',
+            responseType: 'json',
             searchParams: {},
             timeoutSeconds: 30,
             retryPost: false,
@@ -482,6 +525,7 @@ class Fetcher {
                 'logRequestBody',
                 'logResponse',
                 'logResponseBody',
+                'debug',
             ]),
             started: Date.now(),
             ...(0, object_util_1._omit)(opt, ['method', 'headers', 'credentials']),

package/dist/http/fetcher.model.d.ts

@@ -1,8 +1,8 @@
 import type { CommonLogger } from '../log/commonLogger';
 import type { Promisable } from '../typeFest';
-import type { AnyObject, Reviver, UnixTimestampMillisNumber } from '../types';
+import type { AnyObject, NumberOfMilliseconds, Reviver, UnixTimestampMillisNumber } from '../types';
 import type { HttpMethod, HttpStatusFamily } from './http.model';
-export interface FetcherNormalizedCfg extends Required<FetcherCfg>, Omit<FetcherRequest, 'started' | 'fullUrl' | 'logRequest' | 'logRequestBody' | 'logResponse' | 'logResponseBody' | 'redirect' | 'credentials'> {
+export interface FetcherNormalizedCfg extends Required<FetcherCfg>, Omit<FetcherRequest, 'started' | 'fullUrl' | 'logRequest' | 'logRequestBody' | 'logResponse' | 'logResponseBody' | 'debug' | 'redirect' | 'credentials'> {
     logger: CommonLogger;
     searchParams: Record<string, any>;
 }
@@ -68,13 +68,13 @@ export interface FetcherCfg {
 }
 export interface FetcherRetryStatus {
     retryAttempt: number;
-    retryTimeout: number;
+    retryTimeout: NumberOfMilliseconds;
     retryStopped: boolean;
 }
 export interface FetcherRetryOptions {
     count: number;
-    timeout: number;
-    timeoutMax: number;
+    timeout: NumberOfMilliseconds;
+    timeoutMax: NumberOfMilliseconds;
     timeoutMultiplier: number;
 }
 export interface FetcherRequest extends Omit<FetcherOptions, 'method' | 'headers' | 'baseUrl' | 'url'> {
@@ -172,6 +172,10 @@ export interface FetcherOptions {
     logRequestBody?: boolean;
     logResponse?: boolean;
     logResponseBody?: boolean;
+    /**
+     * If true - enables all possible logging.
+     */
+    debug?: boolean;
 }
 export type RequestInitNormalized = Omit<RequestInit, 'method' | 'headers'> & {
     method: HttpMethod;
@@ -201,3 +205,9 @@ export interface FetcherErrorResponse<BODY = unknown> {
 }
 export type FetcherResponse<BODY = unknown> = FetcherSuccessResponse<BODY> | FetcherErrorResponse<BODY>;
 export type FetcherResponseType = 'json' | 'text' | 'void' | 'arrayBuffer' | 'blob' | 'readableStream';
+/**
+ * Function that mocks `Fetcher.callNativeFetch` globally.
+ *
+ * url is `fullUrl` (includes baseUrl and all).
+ */
+export type FetcherMockFunction = (url: string, init: RequestInitNormalized) => Promise<Response>;

package/dist/promise/pTimeout.d.ts

@@ -1,6 +1,6 @@
 import { AppError } from '../error/app.error';
 import type { ErrorData, ErrorObject } from '../error/error.model';
-import type { AnyAsyncFunction } from '../types';
+import type { AnyAsyncFunction, NumberOfMilliseconds } from '../types';
 export declare class TimeoutError extends AppError {
     constructor(message: string, data?: {}, cause?: ErrorObject);
 }
@@ -8,7 +8,7 @@ export interface PTimeoutOptions {
     /**
      * Timeout in milliseconds.
      */
-    timeout: number;
+    timeout: NumberOfMilliseconds;
     /**
      * If set - will be included in the error message.
      * Can be used to identify the place in the code that failed.

package/dist/types.d.ts

@@ -207,3 +207,14 @@ export declare function _typeCast<T>(v: any): asserts v is T;
  * Type-safe Object.assign that checks that part is indeed a Partial<T>
  */
 export declare const _objectAssign: <T extends AnyObject>(target: T, part: Partial<T>) => T;
+/**
+ * Defines a tuple of [err, data]
+ * where only 1 of them exists.
+ * Either error exists and data is null
+ * Or error is null and data is defined.
+ * This forces you to check `if (err)`, which lets
+ * TypeScript infer the existence of `data`.
+ *
+ * Functions like pTry use that.
+ */
+export type ErrorDataTuple<T = unknown, ERR = Error> = [err: null, data: T] | [err: ERR, data: null];

package/dist-esm/error/assert.js

@@ -68,6 +68,17 @@ export function _assertIsError(err, errorClass = Error) {
         });
     }
 }
+/**
+ * Asserts that passed object is indeed an Error of defined ErrorClass.
+ * If yes - returns peacefully (with TypeScript assertion).
+ * In not - throws (re-throws) that error up.
+ */
+export function _assertErrorClassOrRethrow(err, errorClass) {
+    if (!(err instanceof errorClass)) {
+        // re-throw
+        throw err;
+    }
+}
 export function _assertIsErrorObject(obj) {
     if (!_isErrorObject(obj)) {
         const msg = [`expected to be ErrorObject`, `actual typeof: ${typeof obj}`].join('\n');

package/dist-esm/error/try.js

@@ -1,5 +1,6 @@
 import { _stringifyAny } from '../string/stringifyAny';
 import { AppError } from './app.error';
+import { _assertErrorClassOrRethrow } from './assert';
 /**
  * Calls a function, returns a Tuple of [error, value].
  * Allows to write shorter code that avoids `try/catch`.
@@ -7,9 +8,6 @@ import { AppError } from './app.error';
  *
  * Similar to pTry, but for sync functions.
  *
- * 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.
@@ -22,26 +20,29 @@ import { AppError } from './app.error';
  * if (err) ...do something...
  * v // go ahead and use v
  */
-export function _try(fn) {
+export function _try(fn, errorClass) {
     try {
         return [null, fn()];
     }
     catch (err) {
-        return [err, undefined];
+        if (errorClass) {
+            _assertErrorClassOrRethrow(err, errorClass);
+        }
+        return [err, null];
     }
 }
 /**
  * Like _try, but for Promises.
- *
- * Also, intentionally types second return item as non-optional,
- * but you should check for `err` presense first!
  */
-export async function pTry(promise) {
+export async function pTry(promise, errorClass) {
     try {
         return [null, await promise];
     }
     catch (err) {
-        return [err, undefined];
+        if (errorClass) {
+            _assertErrorClassOrRethrow(err, errorClass);
+        }
+        return [err, null];
     }
 }
 /**
@@ -106,5 +107,13 @@ export async function pExpectedError(promise, errorClass) {
  * Shortcut function to simplify error snapshot-matching in tests.
  */
 export async function pExpectedErrorString(promise, errorClass) {
-    return _stringifyAny(await pExpectedError(promise, errorClass));
+    const err = await pExpectedError(promise, errorClass);
+    return _stringifyAny(err);
+}
+/**
+ * Shortcut function to simplify error snapshot-matching in tests.
+ */
+export function _expectedErrorString(fn, errorClass) {
+    const err = _expectedError(fn, errorClass);
+    return _stringifyAny(err);
 }