@naturalcycles/js-lib 14.247.1 → 14.249.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/object/deepEquals.d.ts

@@ -38,7 +38,7 @@
  
  TLDR: _deepEquals should be useful in most of the cases, start there.
  */
-export declare function _deepEquals(a: any, b: any): boolean;
+export declare function _deepEquals<T>(a: T, b: T): boolean;
 /**
  Returns true if a and b are deeply equal.
  
@@ -53,7 +53,7 @@ export declare function _deepEquals(a: any, b: any): boolean;
  
  See _deepEquals docs for more details and comparison.
  */
-export declare function _deepJsonEquals(a: any, b: any): boolean;
+export declare function _deepJsonEquals<T>(a: T, b: T): boolean;
 /**
  * Shortcut for JSON.stringify(a) === JSON.stringify(b)
  *

package/dist/object/deepEquals.js

@@ -55,7 +55,7 @@ function _deepEquals(a, b) {
             return false;
         if (Array.isArray(a)) {
             const length = a.length;
-            if (length !== b.length)
+            if (!Array.isArray(b) || length !== b.length)
                 return false;
             for (let i = length; i-- !== 0;) {
                 if (!_deepEquals(a[i], b[i]))
@@ -79,8 +79,9 @@ function _deepEquals(a, b) {
             }
             return true;
         }
-        if (a.constructor === RegExp)
+        if (a.constructor === RegExp) {
             return a.source === b.source && a.flags === b.flags;
+        }
         if (a.valueOf !== Object.prototype.valueOf)
             return a.valueOf() === b.valueOf();
         if (a.toString !== Object.prototype.toString)
@@ -111,13 +112,16 @@ function _deepJsonEquals(a, b) {
     if (a === b)
         return true;
     if (Number.isNaN(a)) {
+        ;
         a = null;
     }
     else if (typeof a === 'function') {
+        ;
         a = undefined;
     }
     else if (a && typeof a === 'object') {
         if (a instanceof Date) {
+            ;
             a = a.valueOf();
         }
         else if ('toJSON' in a) {
@@ -125,13 +129,16 @@ function _deepJsonEquals(a, b) {
         }
     }
     if (Number.isNaN(b)) {
+        ;
         b = null;
     }
     else if (typeof b === 'function') {
+        ;
         b = undefined;
     }
     else if (b && typeof b === 'object') {
         if (b instanceof Date) {
+            ;
             b = b.valueOf();
         }
         else if ('toJSON' in b) {
@@ -141,7 +148,7 @@ function _deepJsonEquals(a, b) {
     if (a && b && typeof a === 'object' && typeof b === 'object') {
         if (Array.isArray(a)) {
             const length = a.length;
-            if (length !== b.length)
+            if (!Array.isArray(b) || length !== b.length)
                 return false;
             for (let i = length; i-- !== 0;) {
                 if (!_deepJsonEquals(a[i], b[i]))

package/dist/promise/pRetry.js

@@ -51,7 +51,9 @@ async function pRetry(fn, opt = {}) {
         }
         catch (err) {
             if (logFailures) {
-                logger.error(`${fname} attempt #${attempt} error in ${(0, __1._since)(started)}:`, err);
+                // Logger at warn (not error) level, because it's not a fatal error, but a retriable one
+                // Fatal one is not logged either, because it's been thrown instead
+                logger.warn(`${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/object/deepEquals.js

@@ -50,7 +50,7 @@ export function _deepEquals(a, b) {
             return false;
         if (Array.isArray(a)) {
             const length = a.length;
-            if (length !== b.length)
+            if (!Array.isArray(b) || length !== b.length)
                 return false;
             for (let i = length; i-- !== 0;) {
                 if (!_deepEquals(a[i], b[i]))
@@ -74,8 +74,9 @@ export function _deepEquals(a, b) {
             }
             return true;
         }
-        if (a.constructor === RegExp)
+        if (a.constructor === RegExp) {
             return a.source === b.source && a.flags === b.flags;
+        }
         if (a.valueOf !== Object.prototype.valueOf)
             return a.valueOf() === b.valueOf();
         if (a.toString !== Object.prototype.toString)
@@ -106,13 +107,16 @@ export function _deepJsonEquals(a, b) {
     if (a === b)
         return true;
     if (Number.isNaN(a)) {
+        ;
         a = null;
     }
     else if (typeof a === 'function') {
+        ;
         a = undefined;
     }
     else if (a && typeof a === 'object') {
         if (a instanceof Date) {
+            ;
             a = a.valueOf();
         }
         else if ('toJSON' in a) {
@@ -120,13 +124,16 @@ export function _deepJsonEquals(a, b) {
         }
     }
     if (Number.isNaN(b)) {
+        ;
         b = null;
     }
     else if (typeof b === 'function') {
+        ;
         b = undefined;
     }
     else if (b && typeof b === 'object') {
         if (b instanceof Date) {
+            ;
             b = b.valueOf();
         }
         else if ('toJSON' in b) {
@@ -136,7 +143,7 @@ export function _deepJsonEquals(a, b) {
     if (a && b && typeof a === 'object' && typeof b === 'object') {
         if (Array.isArray(a)) {
             const length = a.length;
-            if (length !== b.length)
+            if (!Array.isArray(b) || length !== b.length)
                 return false;
             for (let i = length; i-- !== 0;) {
                 if (!_deepJsonEquals(a[i], b[i]))

package/dist-esm/promise/pRetry.js

@@ -47,7 +47,9 @@ export async function pRetry(fn, opt = {}) {
         }
         catch (err) {
             if (logFailures) {
-                logger.error(`${fname} attempt #${attempt} error in ${_since(started)}:`, err);
+                // Logger at warn (not error) level, because it's not a fatal error, but a retriable one
+                // Fatal one is not logged either, because it's been thrown instead
+                logger.warn(`${fname} attempt #${attempt} error in ${_since(started)}:`, err);
             }
             if (attempt >= maxAttempts || (predicate && !predicate(err, attempt, maxAttempts))) {
                 // Give up

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.247.1",
+  "version": "14.249.0",
   "scripts": {
     "prepare": "husky",
     "build": "dev-lib build-esm-cjs",

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/object/deepEquals.ts

@@ -40,7 +40,7 @@
  
  TLDR: _deepEquals should be useful in most of the cases, start there.
  */
-export function _deepEquals(a: any, b: any): boolean {
+export function _deepEquals<T>(a: T, b: T): boolean {
   if (a === b) return true
 
   if (Number.isNaN(a)) {
@@ -52,7 +52,7 @@ export function _deepEquals(a: any, b: any): boolean {
 
     if (Array.isArray(a)) {
       const length = a.length
-      if (length !== b.length) return false
+      if (!Array.isArray(b) || length !== b.length) return false
       for (let i = length; i-- !== 0; ) {
         if (!_deepEquals(a[i], b[i])) return false
       }
@@ -74,12 +74,14 @@ export function _deepEquals(a: any, b: any): boolean {
       return true
     }
 
-    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags
+    if (a.constructor === RegExp) {
+      return (a as RegExp).source === (b as any).source && (a as RegExp).flags === (b as any).flags
+    }
     if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf()
     if (a.toString !== Object.prototype.toString) return a.toString() === b.toString()
 
     for (const key of new Set([...Object.keys(a), ...Object.keys(b)])) {
-      if (!_deepEquals(a[key], b[key])) return false
+      if (!_deepEquals(a[key as keyof T], b[key as keyof T])) return false
     }
 
     return true
@@ -102,36 +104,36 @@ export function _deepEquals(a: any, b: any): boolean {
  
  See _deepEquals docs for more details and comparison.
  */
-export function _deepJsonEquals(a: any, b: any): boolean {
+export function _deepJsonEquals<T>(a: T, b: T): boolean {
   if (a === b) return true
 
   if (Number.isNaN(a)) {
-    a = null
+    ;(a as any) = null
   } else if (typeof a === 'function') {
-    a = undefined
+    ;(a as any) = undefined
   } else if (a && typeof a === 'object') {
     if (a instanceof Date) {
-      a = a.valueOf()
+      ;(a as any) = a.valueOf()
     } else if ('toJSON' in a) {
-      a = a.toJSON()
+      a = (a as any).toJSON()
     }
   }
   if (Number.isNaN(b)) {
-    b = null
+    ;(b as any) = null
   } else if (typeof b === 'function') {
-    b = undefined
+    ;(b as any) = undefined
   } else if (b && typeof b === 'object') {
     if (b instanceof Date) {
-      b = b.valueOf()
+      ;(b as any) = b.valueOf()
     } else if ('toJSON' in b) {
-      b = b.toJSON()
+      b = (b as any).toJSON()
     }
   }
 
   if (a && b && typeof a === 'object' && typeof b === 'object') {
     if (Array.isArray(a)) {
       const length = a.length
-      if (length !== b.length) return false
+      if (!Array.isArray(b) || length !== b.length) return false
       for (let i = length; i-- !== 0; ) {
         if (!_deepJsonEquals(a[i], b[i])) return false
       }
@@ -139,7 +141,7 @@ export function _deepJsonEquals(a: any, b: any): boolean {
     }
 
     for (const key of new Set([...Object.keys(a), ...Object.keys(b)])) {
-      if (!_deepJsonEquals(a[key], b[key])) return false
+      if (!_deepJsonEquals(a[key as keyof T], b[key as keyof T])) return false
     }
 
     return true

package/src/promise/pRetry.ts

@@ -157,7 +157,9 @@ export async function pRetry<T>(
       return result
     } catch (err) {
       if (logFailures) {
-        logger.error(`${fname} attempt #${attempt} error in ${_since(started)}:`, err)
+        // Logger at warn (not error) level, because it's not a fatal error, but a retriable one
+        // Fatal one is not logged either, because it's been thrown instead
+        logger.warn(`${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.