@naturalcycles/js-lib 14.159.0 → 14.161.0

package/src/error/error.util.ts

@@ -109,41 +109,47 @@ export function _errorObjectToError<DATA_TYPE extends ErrorData, ERROR_TYPE exte
 ): ERROR_TYPE {
   if (o instanceof errorClass) return o
 
-  const err = new errorClass(o.message)
+  // Here we pass constructor values assuming it's AppError or sub-class of it
+  // If not - will be checked at the next step
+  // We cannot check `if (errorClass instanceof AppError)`, only `err instanceof AppError`
+  const { name, cause } = o
+  const err = new errorClass(o.message, o.data, { name, cause })
   // name: err.name, // cannot be assigned to a readonly property like this
   // stack: o.stack, // also readonly e.g in Firefox
 
-  Object.defineProperty(err, 'name', {
-    value: o.name,
-    configurable: true,
-    writable: true,
-  })
-
-  Object.defineProperty(err.constructor, 'name', {
-    value: o.name,
-    configurable: true,
-    writable: true,
-  })
-
-  Object.defineProperty(err, 'data', {
-    value: o.data,
-    writable: true,
-    configurable: true,
-    enumerable: false,
-  })
-
   if (o.stack) {
     Object.defineProperty(err, 'stack', {
       value: o.stack,
     })
   }
 
-  if (o.cause) {
-    Object.defineProperty(err, 'cause', {
-      value: o.cause,
-      writable: true,
+  if (!(err instanceof AppError)) {
+    // Following actions are only needed for non-AppError-like errors
+
+    Object.defineProperties(err, {
+      name: {
+        value: name,
+        configurable: true,
+        writable: true,
+      },
+      data: {
+        value: o.data,
+        writable: true,
+        configurable: true,
+        enumerable: false,
+      },
+      cause: {
+        value: cause,
+        writable: true,
+        configurable: true,
+        enumerable: true,
+      },
+    })
+
+    Object.defineProperty(err.constructor, 'name', {
+      value: name,
       configurable: true,
-      enumerable: false,
+      writable: true,
     })
   }
 

package/src/error/httpRequestError.ts

@@ -1,4 +1,4 @@
-import { AppError } from './app.error'
+import { AppError, AppErrorOptions } from './app.error'
 import type { ErrorObject, HttpRequestErrorData } from './error.model'
 
 /**
@@ -19,8 +19,14 @@ import type { ErrorObject, HttpRequestErrorData } from './error.model'
  * (by default).
  */
 export class HttpRequestError extends AppError<HttpRequestErrorData> {
-  constructor(message: string, data: HttpRequestErrorData, cause: ErrorObject) {
-    super(message, data, cause, 'HttpRequestError')
+  constructor(message: string, data: HttpRequestErrorData, opt?: AppErrorOptions) {
+    if (data.response) {
+      Object.defineProperty(data, 'response', {
+        enumerable: false,
+      })
+    }
+
+    super(message, data, { ...opt, name: 'HttpRequestError' })
   }
 
   /**

package/src/error/jsonParseError.ts

@@ -1,6 +1,6 @@
 import { _truncateMiddle } from '../string/string.util'
 import { AppError } from './app.error'
-import { ErrorData, ErrorObject } from './error.model'
+import { ErrorData } from './error.model'
 
 export interface JsonParseErrorData extends ErrorData {
   /**
@@ -10,12 +10,11 @@ export interface JsonParseErrorData extends ErrorData {
 }
 
 export class JsonParseError extends AppError<JsonParseErrorData> {
-  constructor(data: JsonParseErrorData, cause?: ErrorObject) {
-    super(
-      ['Failed to parse', data.text && _truncateMiddle(data.text, 200)].filter(Boolean).join(': '),
-      data,
-      cause,
-      'JsonParseError',
-    )
+  constructor(data: JsonParseErrorData) {
+    const message = ['Failed to parse', data.text && _truncateMiddle(data.text, 200)]
+      .filter(Boolean)
+      .join(': ')
+
+    super(message, data, { name: 'JsonParseError' })
   }
 }

package/src/error/try.ts

@@ -62,7 +62,13 @@ export async function pTry<T, ERR extends Error = Error>(
  */
 export class UnexpectedPassError extends AppError {
   constructor() {
-    super('expected error was not thrown', {}, undefined, 'UnexpectedPassError')
+    super(
+      'expected error was not thrown',
+      {},
+      {
+        name: 'UnexpectedPassError',
+      },
+    )
   }
 }
 

package/src/http/fetcher.model.ts

@@ -1,3 +1,5 @@
+/// <reference lib="dom"/>
+
 import type { CommonLogger } from '../log/commonLogger'
 import type { Promisable } from '../typeFest'
 import type { AnyObject, NumberOfMilliseconds, Reviver, UnixTimestampMillisNumber } from '../types'

package/src/http/fetcher.ts

@@ -395,6 +395,7 @@ export class Fetcher {
     res.err = new HttpRequestError(
       message,
       _filterNullishValues({
+        response: res.fetchResponse,
         responseStatusCode: res.fetchResponse?.status || 0,
         // These properties are provided to be used in e.g custom Sentry error grouping
         // Actually, disabled now, to avoid unnecessary error printing when both msg and data are printed
@@ -402,12 +403,14 @@ export class Fetcher {
         // method: req.method,
         // tryCount: req.tryCount,
         requestUrl: res.req.fullUrl,
-        requestBaseUrl: this.cfg.baseUrl || (null as any),
+        requestBaseUrl: this.cfg.baseUrl || undefined,
         requestMethod: res.req.init.method,
         requestSignature: res.signature,
         requestDuration: Date.now() - res.req.started,
       }),
-      cause,
+      {
+        cause,
+      },
     )
 
     await this.processRetry(res)
@@ -660,7 +663,7 @@ export class Fetcher {
 
     if (Object.keys(searchParams).length) {
       const qs = new URLSearchParams(searchParams).toString()
-      req.fullUrl += req.fullUrl.includes('?') ? '&' : '?' + qs
+      req.fullUrl += (req.fullUrl.includes('?') ? '&' : '?') + qs
     }
 
     // setup request body

package/src/index.ts

@@ -1,5 +1,5 @@
 export * from './array/array.util'
-export * from './lazy'
+export * from './define'
 export * from './string/url.util'
 export * from './array/range'
 export * from './decorators/createPromiseDecorator'

package/src/object/object.util.ts

@@ -1,6 +1,7 @@
 import { _isEmpty, _isObject } from '../is.util'
 import type { PropertyPath } from '../lodash.types'
-import type { AnyObject, ObjectMapper, ObjectPredicate, StringMap, ValueOf } from '../types'
+import { _objectEntries, KeyValueTuple, SKIP } from '../types'
+import type { AnyObject, ObjectMapper, ObjectPredicate, ValueOf } from '../types'
 
 /**
  * Returns clone of `obj` with only `props` preserved.
@@ -111,24 +112,22 @@ export function _filterObject<T extends AnyObject>(
  *  'pebbles': { 'user': 'pebbles', 'age': 1 }
  * }
  *
- * _.mapValues(users, function(_key, value) { return value.age; });
+ * _mapValues(users, (_key, value) => value.age)
  * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
  *
- * // The `_.property` iteratee shorthand.
- * _.mapValues(users, 'age')
- * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)
+ * To skip some key-value pairs - use _mapObject instead.
  */
-export function _mapValues<T extends AnyObject, OUT = T>(
+export function _mapValues<T extends AnyObject>(
   obj: T,
   mapper: ObjectMapper<T, any>,
   mutate = false,
-): OUT {
-  return Object.entries(obj).reduce(
+): T {
+  return _objectEntries(obj).reduce(
     (map, [k, v]) => {
-      map[k as keyof OUT] = mapper(k, v, obj)
+      map[k] = mapper(k, v, obj)
       return map
     },
-    (mutate ? obj : {}) as OUT,
+    mutate ? obj : ({} as T),
   )
 }
 
@@ -137,15 +136,20 @@ export function _mapValues<T extends AnyObject, OUT = T>(
  * // => { 'a1': 1, 'b2': 2 }
  *
  * Does not support `mutate` flag.
+ *
+ * To skip some key-value pairs - use _mapObject instead.
  */
 export function _mapKeys<T extends AnyObject>(
   obj: T,
   mapper: ObjectMapper<T, string>,
-): StringMap<T[keyof T]> {
-  return Object.entries(obj).reduce((map, [k, v]) => {
-    map[mapper(k, v, obj) as keyof T] = v
-    return map
-  }, {} as T)
+): Record<string, T[keyof T]> {
+  return _objectEntries(obj).reduce(
+    (map, [k, v]) => {
+      map[mapper(k, v, obj)] = v
+      return map
+    },
+    {} as Record<string, T[keyof T]>,
+  )
 }
 
 /**
@@ -160,24 +164,21 @@ export function _mapKeys<T extends AnyObject>(
  * 0 - key of returned object (string)
  * 1 - value of returned object (any)
  *
- * If predicate returns falsy value (e.g undefined), or a tuple where key (first item) is falsy - then such key/value pair is ignored (filtered out).
+ * If predicate returns SKIP symbol - such key/value pair is ignored (filtered out).
  *
  * Non-string keys are passed via String(...)
  */
-export function _mapObject<IN extends AnyObject, OUT>(
-  obj: IN,
-  mapper: ObjectMapper<IN, [key: string, value: any]>,
-): { [P in keyof IN]: OUT } {
-  return Object.entries(obj).reduce(
-    (map, [k, v]) => {
-      const r = mapper(k, v, obj) || []
-      if (r[0]) {
-        ;(map[r[0]] as any) = r[1]
-      }
-      return map
-    },
-    {} as { [P in keyof IN]: OUT },
-  )
+export function _mapObject<T extends AnyObject>(
+  obj: T,
+  mapper: ObjectMapper<T, KeyValueTuple<string, any> | typeof SKIP>,
+): T {
+  return Object.entries(obj).reduce((map, [k, v]) => {
+    const r = mapper(k, v, obj)
+    if (r !== SKIP) {
+      map[r[0]] = r[1]
+    }
+    return map
+  }, {} as AnyObject) as T
 }
 
 export function _findKeyByValue<T extends AnyObject>(obj: T, v: ValueOf<T>): keyof T | undefined {
@@ -404,3 +405,23 @@ export function _has<T extends AnyObject>(obj: T, path: string): boolean {
   const v = _get(obj, path)
   return v !== undefined && v !== null
 }
+
+/**
+ * Does Object.freeze recursively for given object.
+ *
+ * Based on: https://github.com/substack/deep-freeze/blob/master/index.js
+ */
+export function _deepFreeze(o: any): void {
+  Object.freeze(o)
+
+  Object.getOwnPropertyNames(o).forEach(prop => {
+    if (
+      o.hasOwnProperty(prop) && // eslint-disable-line no-prototype-builtins
+      o[prop] !== null &&
+      (typeof o[prop] === 'object' || typeof o[prop] === 'function') &&
+      !Object.isFrozen(o[prop])
+    ) {
+      _deepFreeze(o[prop])
+    }
+  })
+}

package/src/promise/pTimeout.ts

@@ -1,11 +1,11 @@
-import { AppError } from '../error/app.error'
-import type { ErrorData, ErrorObject } from '../error/error.model'
+import { AppError, AppErrorOptions } from '../error/app.error'
+import type { ErrorData } from '../error/error.model'
 import { _errorDataAppend } from '../error/error.util'
 import type { AnyAsyncFunction, NumberOfMilliseconds } from '../types'
 
 export class TimeoutError extends AppError {
-  constructor(message: string, data = {}, cause?: ErrorObject) {
-    super(message, data, cause, 'TimeoutError')
+  constructor(message: string, data?: ErrorData, opt?: AppErrorOptions) {
+    super(message, data, { ...opt, name: 'TimeoutError' })
   }
 }
 

package/src/types.ts

@@ -163,7 +163,7 @@ export type KeyValueTuple<K, V> = [key: K, value: V]
 
 // Exclude<something, undefined> is used here to support StringMap<OBJ> (because values of StringMap add `undefined`)
 export type ObjectMapper<OBJ, OUT> = (
-  key: string,
+  key: keyof OBJ,
   value: Exclude<OBJ[keyof OBJ], undefined>,
   obj: OBJ,
 ) => OUT
@@ -250,11 +250,21 @@ export const _stringMapValues = Object.values as <T>(m: StringMap<T>) => T[]
 export const _stringMapEntries = Object.entries as <T>(m: StringMap<T>) => [k: string, v: T][]
 
 /**
- * Like `Object.keys`, but returns keys typed as `keyof T`, not as just `string`.
+ * Alias of `Object.keys`, but returns keys typed as `keyof T`, not as just `string`.
  * This is how TypeScript should work, actually.
  */
 export const _objectKeys = Object.keys as <T extends AnyObject>(obj: T) => (keyof T)[]
 
+/**
+ * Alias of `Object.entries`, but returns better-typed output.
+ *
+ * So e.g you can use _objectEntries(obj).map([k, v] => {})
+ * and `k` will be `keyof obj` instead of generic `string`.
+ */
+export const _objectEntries = Object.entries as <T extends AnyObject>(
+  obj: T,
+) => [k: keyof T, v: T[keyof T]][]
+
 export type NullishValue = null | undefined
 export type FalsyValue = false | '' | 0 | null | undefined
 

package/dist/lazy.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._defineLazyProps = exports._defineLazyProperty = exports._lazyValue = void 0;
-/**
- * const value = lazyValue(() => expensiveComputation())
- *
- * value() // calls expensiveComputation() once
- * value() // returns cached result
- * value() // returns cached result
- *
- * Based on: https://github.com/sindresorhus/lazy-value
- */
-function _lazyValue(fn) {
-    let isCalled = false;
-    let result;
-    return (() => {
-        if (!isCalled) {
-            isCalled = true;
-            result = fn();
-        }
-        return result;
-    });
-}
-exports._lazyValue = _lazyValue;
-/**
- * interface Obj {
- *   v: number
- * }
- *
- * const obj = {} as Obj
- *
- * _defineLazyProperty(obj, 'v', () => expensiveComputation())
- * obj.v // runs expensiveComputation() once
- * obj.v // cached value
- * obj.v // cached value
- *
- * Based on: https://github.com/sindresorhus/define-lazy-prop
- */
-function _defineLazyProperty(obj, propertyName, fn) {
-    const define = (value) => {
-        Object.defineProperty(obj, propertyName, { value, enumerable: true, writable: true });
-    };
-    Object.defineProperty(obj, propertyName, {
-        configurable: true,
-        enumerable: true,
-        get() {
-            const result = fn();
-            define(result);
-            return result;
-        },
-        set(value) {
-            define(value);
-        },
-    });
-    return obj;
-}
-exports._defineLazyProperty = _defineLazyProperty;
-/**
- * Like _defineLazyProperty, but allows to define multiple props at once.
- */
-function _defineLazyProps(obj, props) {
-    Object.entries(props).forEach(([k, fn]) => _defineLazyProperty(obj, k, fn));
-    return obj;
-}
-exports._defineLazyProps = _defineLazyProps;