@naturalcycles/js-lib 14.227.0 → 14.228.0

package/dist/decorators/timeout.decorator.js

@@ -8,6 +8,8 @@ const decorator_util_1 = require("./decorator.util");
 function _Timeout(opt) {
     return (target, key, descriptor) => {
         (0, assert_1._assert)(typeof descriptor.value === 'function', '@_Timeout can be applied only to methods');
+        if (!opt.timeout)
+            return descriptor;
         const originalFn = descriptor.value;
         const keyStr = String(key);
         descriptor.value = async function (...args) {

package/dist/promise/pTimeout.d.ts

@@ -4,6 +4,8 @@ import type { AnyAsyncFunction, NumberOfMilliseconds } from '../types';
 export interface PTimeoutOptions {
     /**
      * Timeout in milliseconds.
+     *
+     * If 0 is passed - the function would be executed right away, with no timeout.
      */
     timeout: NumberOfMilliseconds;
     /**

package/dist/promise/pTimeout.js

@@ -11,6 +11,9 @@ const error_util_1 = require("../error/error.util");
  */
 function pTimeoutFn(fn, opt) {
     opt.name ||= fn.name;
+    if (!opt.timeout) {
+        return fn;
+    }
     return async function pTimeoutInternalFn(...args) {
         return await pTimeout(() => fn.apply(this, args), opt);
     };
@@ -23,6 +26,10 @@ exports.pTimeoutFn = pTimeoutFn;
  * If the Function rejects - passes this rejection further.
  */
 async function pTimeout(fn, opt) {
+    if (!opt.timeout) {
+        // short-circuit to direct execution if 0 timeout is passed
+        return await fn();
+    }
     const { timeout, name = fn.name || 'pTimeout function', onTimeout } = opt;
     const fakeError = opt.fakeError || new Error('TimeoutError');
     // eslint-disable-next-line no-async-promise-executor

package/dist-esm/decorators/timeout.decorator.js

@@ -5,6 +5,8 @@ import { _getMethodSignature } from './decorator.util';
 export function _Timeout(opt) {
     return (target, key, descriptor) => {
         _assert(typeof descriptor.value === 'function', '@_Timeout can be applied only to methods');
+        if (!opt.timeout)
+            return descriptor;
         const originalFn = descriptor.value;
         const keyStr = String(key);
         descriptor.value = async function (...args) {

package/dist-esm/promise/pTimeout.js

@@ -8,6 +8,9 @@ import { _errorDataAppend, TimeoutError } from '../error/error.util';
  */
 export function pTimeoutFn(fn, opt) {
     opt.name || (opt.name = fn.name);
+    if (!opt.timeout) {
+        return fn;
+    }
     return async function pTimeoutInternalFn(...args) {
         return await pTimeout(() => fn.apply(this, args), opt);
     };
@@ -19,6 +22,10 @@ export function pTimeoutFn(fn, opt) {
  * If the Function rejects - passes this rejection further.
  */
 export async function pTimeout(fn, opt) {
+    if (!opt.timeout) {
+        // short-circuit to direct execution if 0 timeout is passed
+        return await fn();
+    }
     const { timeout, name = fn.name || 'pTimeout function', onTimeout } = opt;
     const fakeError = opt.fakeError || new Error('TimeoutError');
     // eslint-disable-next-line no-async-promise-executor

package/package.json

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

package/src/decorators/timeout.decorator.ts

@@ -8,6 +8,8 @@ export function _Timeout(opt: PTimeoutOptions): MethodDecorator {
   return (target, key, descriptor) => {
     _assert(typeof descriptor.value === 'function', '@_Timeout can be applied only to methods')
 
+    if (!opt.timeout) return descriptor
+
     const originalFn = descriptor.value
     const keyStr = String(key)
 

package/src/promise/pTimeout.ts

@@ -5,6 +5,8 @@ import type { AnyAsyncFunction, NumberOfMilliseconds } from '../types'
 export interface PTimeoutOptions {
   /**
    * Timeout in milliseconds.
+   *
+   * If 0 is passed - the function would be executed right away, with no timeout.
    */
   timeout: NumberOfMilliseconds
 
@@ -46,6 +48,10 @@ export interface PTimeoutOptions {
 export function pTimeoutFn<T extends AnyAsyncFunction>(fn: T, opt: PTimeoutOptions): T {
   opt.name ||= fn.name
 
+  if (!opt.timeout) {
+    return fn
+  }
+
   return async function pTimeoutInternalFn(this: any, ...args: any[]) {
     return await pTimeout(() => fn.apply(this, args), opt)
   } as T
@@ -58,6 +64,11 @@ export function pTimeoutFn<T extends AnyAsyncFunction>(fn: T, opt: PTimeoutOptio
  * If the Function rejects - passes this rejection further.
  */
 export async function pTimeout<T>(fn: AnyAsyncFunction<T>, opt: PTimeoutOptions): Promise<T> {
+  if (!opt.timeout) {
+    // short-circuit to direct execution if 0 timeout is passed
+    return await fn()
+  }
+
   const { timeout, name = fn.name || 'pTimeout function', onTimeout } = opt
   const fakeError = opt.fakeError || new Error('TimeoutError')