@naturalcycles/js-lib 14.247.0 → 14.248.0

package/dist/define.d.ts

@@ -1,4 +1,4 @@
-import type { AnyFunction, AnyObject } from './types';
+import type { AnyFunction, AnyObject, Lazy } from './types';
 /**
  * const value = lazyValue(() => expensiveComputation())
  *
@@ -8,7 +8,7 @@ import type { AnyFunction, AnyObject } from './types';
  *
  * Based on: https://github.com/sindresorhus/lazy-value
  */
-export declare function _lazyValue<T extends AnyFunction>(fn: T): T;
+export declare function _lazyValue<T>(fn: () => T): Lazy<T>;
 /**
  * interface Obj {
  *   v: number

package/dist/promise/pRetry.js

@@ -15,7 +15,7 @@ function pRetryFn(fn, opt = {}) {
 async function pRetry(fn, opt = {}) {
     const { maxAttempts = 4, delay: initialDelay = 1000, delayMultiplier = 2, predicate, logger = console, name, timeout, } = opt;
     const fakeError = timeout ? new Error('TimeoutError') : undefined;
-    let { logFirstAttempt = false, logRetries = true, logFailures = false, logSuccess = false } = opt;
+    let { logFirstAttempt = false, logRetries = true, logFailures = true, logSuccess = false } = opt;
     if (opt.logAll) {
         logSuccess = logFirstAttempt = logRetries = logFailures = true;
     }
@@ -51,7 +51,7 @@ async function pRetry(fn, opt = {}) {
         }
         catch (err) {
             if (logFailures) {
-                logger.warn(`${fname} attempt #${attempt} error in ${(0, __1._since)(started)}:`, err);
+                logger.error(`${fname} attempt #${attempt} error in ${(0, __1._since)(started)}:`, err);
             }
             if (attempt >= maxAttempts || (predicate && !predicate(err, attempt, maxAttempts))) {
                 // Give up

package/dist/types.d.ts

@@ -71,6 +71,18 @@ export type AnyAsyncFunction<T = any> = (...args: any[]) => Promise<T>;
 export type AsyncFunction<T = any> = () => Promise<T>;
 export type AnyPromisableFunction<T = any> = (...args: any[]) => Promisable<T>;
 export type PromisableFunction<T = any> = () => Promisable<T>;
+/**
+ * A function that lazily calculates something.
+ */
+export type Lazy<T> = () => T;
+/**
+ * A function that lazily calculates something async (returns a Promise).
+ */
+export type LazyPromise<T> = () => Promise<T>;
+/**
+ * A function that lazily calculates something async, that can return null.
+ */
+export type LazyNullablePromise<T> = () => Promise<T | null>;
 /**
  * Symbol to indicate END of Sequence.
  */

package/dist-esm/promise/pRetry.js

@@ -11,7 +11,7 @@ export function pRetryFn(fn, opt = {}) {
 export async function pRetry(fn, opt = {}) {
     const { maxAttempts = 4, delay: initialDelay = 1000, delayMultiplier = 2, predicate, logger = console, name, timeout, } = opt;
     const fakeError = timeout ? new Error('TimeoutError') : undefined;
-    let { logFirstAttempt = false, logRetries = true, logFailures = false, logSuccess = false } = opt;
+    let { logFirstAttempt = false, logRetries = true, logFailures = true, logSuccess = false } = opt;
     if (opt.logAll) {
         logSuccess = logFirstAttempt = logRetries = logFailures = true;
     }
@@ -47,7 +47,7 @@ export async function pRetry(fn, opt = {}) {
         }
         catch (err) {
             if (logFailures) {
-                logger.warn(`${fname} attempt #${attempt} error in ${_since(started)}:`, err);
+                logger.error(`${fname} attempt #${attempt} error in ${_since(started)}:`, err);
             }
             if (attempt >= maxAttempts || (predicate && !predicate(err, attempt, maxAttempts))) {
                 // Give up

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.247.0",
+  "version": "14.248.0",
   "scripts": {
     "prepare": "husky",
-    "build-prod": "build-prod-esm-cjs",
+    "build": "dev-lib build-esm-cjs",
+    "test": "dev-lib test",
+    "lint": "dev-lib lint",
+    "bt": "dev-lib bt",
+    "lbt": "dev-lib lbt",
     "test-tz1": "TZ=Europe/Stockholm yarn test local",
     "test-tz2": "TZ=JST-9 yarn test local",
     "test-ny": "TZ=GMT-0500 yarn test localTime",
@@ -17,11 +21,11 @@
   },
   "devDependencies": {
     "@naturalcycles/bench-lib": "^3.0.0",
-    "@naturalcycles/dev-lib": "^14.0.0",
+    "@naturalcycles/dev-lib": "^15.0.3",
     "@naturalcycles/nodejs-lib": "^13.0.1",
     "@naturalcycles/time-lib": "^3.5.1",
     "@types/crypto-js": "^4.1.1",
-    "@types/node": "^20.1.0",
+    "@types/node": "^22.0.0",
     "@types/semver": "^7.5.8",
     "crypto-js": "^4.1.1",
     "jest": "^29.0.0",

package/src/define.ts

@@ -1,5 +1,5 @@
 import { _mapObject, _mapValues } from './object/object.util'
-import type { AnyFunction, AnyObject } from './types'
+import type { AnyFunction, AnyObject, Lazy } from './types'
 import { SKIP } from './types'
 
 /**
@@ -11,7 +11,7 @@ import { SKIP } from './types'
  *
  * Based on: https://github.com/sindresorhus/lazy-value
  */
-export function _lazyValue<T extends AnyFunction>(fn: T): T {
+export function _lazyValue<T>(fn: () => T): Lazy<T> {
   let isCalled = false
   let result: any
 

package/src/promise/pRetry.ts

@@ -114,7 +114,7 @@ export async function pRetry<T>(
   } = opt
 
   const fakeError = timeout ? new Error('TimeoutError') : undefined
-  let { logFirstAttempt = false, logRetries = true, logFailures = false, logSuccess = false } = opt
+  let { logFirstAttempt = false, logRetries = true, logFailures = true, logSuccess = false } = opt
 
   if (opt.logAll) {
     logSuccess = logFirstAttempt = logRetries = logFailures = true
@@ -157,7 +157,7 @@ export async function pRetry<T>(
       return result
     } catch (err) {
       if (logFailures) {
-        logger.warn(`${fname} attempt #${attempt} error in ${_since(started)}:`, err)
+        logger.error(`${fname} attempt #${attempt} error in ${_since(started)}:`, err)
       }
 
       if (attempt >= maxAttempts || (predicate && !predicate(err as Error, attempt, maxAttempts))) {

package/src/types.ts

@@ -90,6 +90,18 @@ export type AnyAsyncFunction<T = any> = (...args: any[]) => Promise<T>
 export type AsyncFunction<T = any> = () => Promise<T>
 export type AnyPromisableFunction<T = any> = (...args: any[]) => Promisable<T>
 export type PromisableFunction<T = any> = () => Promisable<T>
+/**
+ * A function that lazily calculates something.
+ */
+export type Lazy<T> = () => T
+/**
+ * A function that lazily calculates something async (returns a Promise).
+ */
+export type LazyPromise<T> = () => Promise<T>
+/**
+ * A function that lazily calculates something async, that can return null.
+ */
+export type LazyNullablePromise<T> = () => Promise<T | null>
 
 /**
  * Symbol to indicate END of Sequence.