@naturalcycles/js-lib 14.159.0 → 14.161.0

package/dist/types.d.ts

@@ -120,7 +120,7 @@ export type ValuesOf<T extends readonly any[]> = T[number];
  */
 export type ValueOf<T> = T[keyof T];
 export type KeyValueTuple<K, V> = [key: K, value: V];
-export type ObjectMapper<OBJ, OUT> = (key: string, value: Exclude<OBJ[keyof OBJ], undefined>, obj: OBJ) => OUT;
+export type ObjectMapper<OBJ, OUT> = (key: keyof OBJ, value: Exclude<OBJ[keyof OBJ], undefined>, obj: OBJ) => OUT;
 export type ObjectPredicate<OBJ> = (key: keyof OBJ, value: Exclude<OBJ[keyof OBJ], undefined>, obj: OBJ) => boolean;
 /**
  * Allows to identify instance of Class by `instanceId`.
@@ -185,10 +185,17 @@ export declare const _stringMapValues: <T>(m: StringMap<T>) => T[];
  */
 export declare const _stringMapEntries: <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 declare const _objectKeys: <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 declare const _objectEntries: <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/types.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._objectAssign = exports._typeCast = exports._objectKeys = exports._stringMapEntries = exports._stringMapValues = exports._passNothingPredicate = exports._passthroughPredicate = exports._noop = exports._passUndefinedMapper = exports._passthroughMapper = exports.SKIP = exports.END = void 0;
+exports._objectAssign = exports._typeCast = exports._objectEntries = exports._objectKeys = exports._stringMapEntries = exports._stringMapValues = exports._passNothingPredicate = exports._passthroughPredicate = exports._noop = exports._passUndefinedMapper = exports._passthroughMapper = exports.SKIP = exports.END = void 0;
 /**
  * Symbol to indicate END of Sequence.
  */
@@ -33,10 +33,17 @@ exports._stringMapValues = Object.values;
  */
 exports._stringMapEntries = Object.entries;
 /**
- * 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.
  */
 exports._objectKeys = Object.keys;
+/**
+ * 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`.
+ */
+exports._objectEntries = Object.entries;
 /**
  * Utility function that helps to cast *existing variable* to needed type T.
  *

package/dist-esm/{lazy.js → define.js}

@@ -1,3 +1,5 @@
+import { _mapObject, _mapValues } from './object/object.util';
+import { SKIP } from './types';
 /**
  * const value = lazyValue(() => expensiveComputation())
  *
@@ -57,3 +59,39 @@ export function _defineLazyProps(obj, props) {
     Object.entries(props).forEach(([k, fn]) => _defineLazyProperty(obj, k, fn));
     return obj;
 }
+/**
+ * Same as Object.defineProperty, but with better (least restricting) defaults.
+ *
+ * Defaults are:
+ * writable: true
+ * configurable: true
+ * enumerable: true
+ * value: existing obj[prop] value
+ *
+ * Original defaults:
+ * writable: false
+ * configurable: false
+ * enumerable: false
+ * value: existing obj[prop] value
+ *
+ */
+export function _defineProperty(obj, prop, pd) {
+    return Object.defineProperty(obj, prop, Object.assign({ writable: true, configurable: true, enumerable: true }, pd));
+}
+/**
+ * Object.defineProperties with better defaults.
+ * See _defineProperty for exact defaults definition.
+ */
+export function _defineProps(obj, props) {
+    return Object.defineProperties(obj, _mapValues(props, (k, pd) => (Object.assign({ writable: true, configurable: true, enumerable: true }, pd))));
+}
+/**
+ * Like _defineProps, but skips props with nullish values.
+ */
+export function _defineNonNullishProps(obj, props) {
+    return _defineProps(obj, _mapObject(props, (k, pd) => {
+        if (pd.value === null || pd.value === undefined)
+            return SKIP;
+        return [k, pd];
+    }));
+}

package/dist-esm/error/app.error.js

@@ -3,29 +3,26 @@
  *
  * message - "technical" message. Frontend decides to show it or not.
  * data - optional "any" payload.
- * data.userMessage - if present, will be displayed to the User as is.
+ * data.userFriendly - if present, will be displayed to the User as is.
  *
  * Based on: https://medium.com/@xpl/javascript-deriving-from-error-properly-8d2f8f315801
  */
 export class AppError extends Error {
-    constructor(message, data = {}, cause, name) {
+    constructor(message, data = {}, opt = {}) {
         super(message);
-        Object.defineProperty(this, 'name', {
-            value: name || this.constructor.name,
-            configurable: true,
-            writable: true,
-        });
-        // this is to allow changing this.constuctor.name to a non-minified version
-        Object.defineProperty(this.constructor, 'name', {
-            value: name || this.constructor.name,
-            configurable: true,
-            writable: true,
-        });
-        Object.defineProperty(this, 'data', {
-            value: data,
-            writable: true,
-            configurable: true,
-            enumerable: false,
+        const { name = this.constructor.name, cause } = opt;
+        Object.defineProperties(this, {
+            name: {
+                value: name,
+                configurable: true,
+                writable: true,
+            },
+            data: {
+                value: data,
+                writable: true,
+                configurable: true,
+                enumerable: false,
+            },
         });
         if (cause) {
             Object.defineProperty(this, 'cause', {
@@ -33,9 +30,15 @@ export class AppError extends Error {
                 value: cause,
                 writable: true,
                 configurable: true,
-                enumerable: false,
+                enumerable: true, // unlike standard - setting it to true for "visibility"
             });
         }
+        // this is to allow changing this.constuctor.name to a non-minified version
+        Object.defineProperty(this.constructor, 'name', {
+            value: name,
+            configurable: true,
+            writable: true,
+        });
         // todo: check if it's needed at all!
         // if (Error.captureStackTrace) {
         //   Error.captureStackTrace(this, this.constructor)

package/dist-esm/error/assert.js

@@ -106,7 +106,7 @@ export function _assertTypeOf(v, expectedType, message) {
     }
 }
 export class AssertionError extends AppError {
-    constructor(message, data = {}, cause) {
-        super(message, data, cause, 'AssertionError');
+    constructor(message, data) {
+        super(message, data, { name: 'AssertionError' });
     }
 }

package/dist-esm/error/error.util.js

@@ -1,4 +1,4 @@
-import { _jsonParseIfPossible, _stringifyAny } from '..';
+import { AppError, _jsonParseIfPossible, _stringifyAny } from '..';
 /**
  * Useful to ensure that error in `catch (err) { ... }`
  * is indeed an Error (and not e.g `string` or `undefined`).
@@ -78,36 +78,43 @@ export function _errorLikeToErrorObject(e) {
 export function _errorObjectToError(o, errorClass = Error) {
     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,
         });
     }
     return err;

package/dist-esm/error/httpRequestError.js

@@ -17,7 +17,12 @@ import { AppError } from './app.error';
  * (by default).
  */
 export class HttpRequestError extends AppError {
-    constructor(message, data, cause) {
-        super(message, data, cause, 'HttpRequestError');
+    constructor(message, data, opt) {
+        if (data.response) {
+            Object.defineProperty(data, 'response', {
+                enumerable: false,
+            });
+        }
+        super(message, data, Object.assign(Object.assign({}, opt), { name: 'HttpRequestError' }));
     }
 }

package/dist-esm/error/jsonParseError.js

@@ -1,7 +1,10 @@
 import { _truncateMiddle } from '../string/string.util';
 import { AppError } from './app.error';
 export class JsonParseError extends AppError {
-    constructor(data, cause) {
-        super(['Failed to parse', data.text && _truncateMiddle(data.text, 200)].filter(Boolean).join(': '), data, cause, 'JsonParseError');
+    constructor(data) {
+        const message = ['Failed to parse', data.text && _truncateMiddle(data.text, 200)]
+            .filter(Boolean)
+            .join(': ');
+        super(message, data, { name: 'JsonParseError' });
     }
 }

package/dist-esm/error/try.js

@@ -52,7 +52,9 @@ export async function pTry(promise, errorClass) {
  */
 export class UnexpectedPassError extends AppError {
     constructor() {
-        super('expected error was not thrown', {}, undefined, 'UnexpectedPassError');
+        super('expected error was not thrown', {}, {
+            name: 'UnexpectedPassError',
+        });
     }
 }
 /**

package/dist-esm/http/fetcher.js

@@ -295,6 +295,7 @@ export class Fetcher {
         });
         const message = [(_a = res.fetchResponse) === null || _a === void 0 ? void 0 : _a.status, res.signature].filter(Boolean).join(' ');
         res.err = new HttpRequestError(message, _filterNullishValues({
+            response: res.fetchResponse,
             responseStatusCode: ((_b = res.fetchResponse) === null || _b === void 0 ? void 0 : _b.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
@@ -302,11 +303,13 @@ export class Fetcher {
             // method: req.method,
             // tryCount: req.tryCount,
             requestUrl: res.req.fullUrl,
-            requestBaseUrl: this.cfg.baseUrl || null,
+            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);
     }
     async processRetry(res) {
@@ -512,7 +515,7 @@ export class Fetcher {
         const searchParams = _filterUndefinedValues(Object.assign(Object.assign({}, this.cfg.searchParams), opt.searchParams));
         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
         if (opt.json !== undefined) {

package/dist-esm/http/fetcher.model.js

@@ -1 +1,2 @@
+/// <reference lib="dom"/>
 export {};

package/dist-esm/index.js

@@ -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/dist-esm/object/object.util.js

@@ -1,4 +1,5 @@
 import { _isEmpty, _isObject } from '../is.util';
+import { _objectEntries, SKIP } from '../types';
 /**
  * Returns clone of `obj` with only `props` preserved.
  * Opposite of Omit.
@@ -82,27 +83,27 @@ export function _filterObject(obj, predicate, mutate = false) {
  *  '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(obj, mapper, mutate = false) {
-    return Object.entries(obj).reduce((map, [k, v]) => {
+    return _objectEntries(obj).reduce((map, [k, v]) => {
         map[k] = mapper(k, v, obj);
         return map;
-    }, (mutate ? obj : {}));
+    }, mutate ? obj : {});
 }
 /**
  * _.mapKeys({ 'a': 1, 'b': 2 }, (key, value) => key + value)
  * // => { 'a1': 1, 'b2': 2 }
  *
  * Does not support `mutate` flag.
+ *
+ * To skip some key-value pairs - use _mapObject instead.
  */
 export function _mapKeys(obj, mapper) {
-    return Object.entries(obj).reduce((map, [k, v]) => {
+    return _objectEntries(obj).reduce((map, [k, v]) => {
         map[mapper(k, v, obj)] = v;
         return map;
     }, {});
@@ -119,15 +120,14 @@ export function _mapKeys(obj, mapper) {
  * 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(obj, mapper) {
     return Object.entries(obj).reduce((map, [k, v]) => {
-        const r = mapper(k, v, obj) || [];
-        if (r[0]) {
-            ;
+        const r = mapper(k, v, obj);
+        if (r !== SKIP) {
             map[r[0]] = r[1];
         }
         return map;
@@ -342,3 +342,19 @@ export function _has(obj, path) {
     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) {
+    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/dist-esm/promise/pTimeout.js

@@ -1,8 +1,8 @@
 import { AppError } from '../error/app.error';
 import { _errorDataAppend } from '../error/error.util';
 export class TimeoutError extends AppError {
-    constructor(message, data = {}, cause) {
-        super(message, data, cause, 'TimeoutError');
+    constructor(message, data, opt) {
+        super(message, data, Object.assign(Object.assign({}, opt), { name: 'TimeoutError' }));
     }
 }
 /**

package/dist-esm/types.js

@@ -25,10 +25,17 @@ export const _stringMapValues = Object.values;
  */
 export const _stringMapEntries = Object.entries;
 /**
- * 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;
+/**
+ * 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;
 /**
  * Utility function that helps to cast *existing variable* to needed type T.
  *

package/package.json

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

package/src/{lazy.ts → define.ts}

@@ -1,3 +1,5 @@
+import { _mapObject, _mapValues } from './object/object.util'
+import { SKIP } from './types'
 import type { AnyFunction, AnyObject } from './types'
 
 /**
@@ -72,3 +74,69 @@ export function _defineLazyProps<OBJ extends AnyObject>(
   Object.entries(props).forEach(([k, fn]) => _defineLazyProperty(obj, k, fn!))
   return obj
 }
+
+/**
+ * Same as Object.defineProperty, but with better (least restricting) defaults.
+ *
+ * Defaults are:
+ * writable: true
+ * configurable: true
+ * enumerable: true
+ * value: existing obj[prop] value
+ *
+ * Original defaults:
+ * writable: false
+ * configurable: false
+ * enumerable: false
+ * value: existing obj[prop] value
+ *
+ */
+export function _defineProperty<T extends AnyObject>(
+  obj: T,
+  prop: keyof T,
+  pd: PropertyDescriptor,
+): T {
+  return Object.defineProperty(obj, prop, {
+    writable: true,
+    configurable: true,
+    enumerable: true,
+    // value: obj[prop], // existing value is already kept by default
+    ...pd,
+  })
+}
+
+/**
+ * Object.defineProperties with better defaults.
+ * See _defineProperty for exact defaults definition.
+ */
+export function _defineProps<T extends AnyObject>(
+  obj: T,
+  props: Partial<Record<keyof T, PropertyDescriptor>>,
+): T {
+  return Object.defineProperties(
+    obj,
+    _mapValues(props, (k, pd) => ({
+      writable: true,
+      configurable: true,
+      enumerable: true,
+      // value: obj[k], // existing value is already kept by default
+      ...pd,
+    })) as PropertyDescriptorMap,
+  )
+}
+
+/**
+ * Like _defineProps, but skips props with nullish values.
+ */
+export function _defineNonNullishProps<T extends AnyObject>(
+  obj: T,
+  props: Partial<Record<keyof T, PropertyDescriptor>>,
+): T {
+  return _defineProps(
+    obj,
+    _mapObject(props, (k, pd) => {
+      if (pd.value === null || pd.value === undefined) return SKIP
+      return [k as string, pd]
+    }),
+  )
+}

package/src/error/app.error.ts

@@ -5,7 +5,7 @@ import type { ErrorData, ErrorObject } from './error.model'
  *
  * message - "technical" message. Frontend decides to show it or not.
  * data - optional "any" payload.
- * data.userMessage - if present, will be displayed to the User as is.
+ * data.userFriendly - if present, will be displayed to the User as is.
  *
  * Based on: https://medium.com/@xpl/javascript-deriving-from-error-properly-8d2f8f315801
  */
@@ -13,31 +13,26 @@ export class AppError<DATA_TYPE extends ErrorData = ErrorData> extends Error {
   data!: DATA_TYPE
 
   /**
-   * cause here is normalized to be an ErrorObject
+   * `cause` here is normalized to be an ErrorObject
    */
   override cause?: ErrorObject
 
-  constructor(message: string, data = {} as DATA_TYPE, cause?: ErrorObject, name?: string) {
+  constructor(message: string, data = {} as DATA_TYPE, opt: AppErrorOptions = {}) {
     super(message)
+    const { name = this.constructor.name, cause } = opt
 
-    Object.defineProperty(this, 'name', {
-      value: name || this.constructor.name,
-      configurable: true,
-      writable: true,
-    })
-
-    // this is to allow changing this.constuctor.name to a non-minified version
-    Object.defineProperty(this.constructor, 'name', {
-      value: name || this.constructor.name,
-      configurable: true,
-      writable: true,
-    })
-
-    Object.defineProperty(this, 'data', {
-      value: data,
-      writable: true,
-      configurable: true,
-      enumerable: false,
+    Object.defineProperties(this, {
+      name: {
+        value: name,
+        configurable: true,
+        writable: true,
+      },
+      data: {
+        value: data,
+        writable: true,
+        configurable: true,
+        enumerable: false,
+      },
     })
 
     if (cause) {
@@ -46,10 +41,17 @@ export class AppError<DATA_TYPE extends ErrorData = ErrorData> extends Error {
         value: cause,
         writable: true,
         configurable: true,
-        enumerable: false,
+        enumerable: true, // unlike standard - setting it to true for "visibility"
       })
     }
 
+    // this is to allow changing this.constuctor.name to a non-minified version
+    Object.defineProperty(this.constructor, 'name', {
+      value: name,
+      configurable: true,
+      writable: true,
+    })
+
     // todo: check if it's needed at all!
     // if (Error.captureStackTrace) {
     //   Error.captureStackTrace(this, this.constructor)
@@ -62,3 +64,18 @@ export class AppError<DATA_TYPE extends ErrorData = ErrorData> extends Error {
     // }
   }
 }
+
+/**
+ * Extra options for AppError constructor.
+ */
+export interface AppErrorOptions {
+  /**
+   * Overrides Error.name and Error.constructor.name
+   */
+  name?: string
+
+  /**
+   * Sets Error.cause
+   */
+  cause?: ErrorObject
+}

package/src/error/assert.ts

@@ -152,7 +152,7 @@ export function _assertTypeOf<T>(v: any, expectedType: string, message?: string)
 }
 
 export class AssertionError extends AppError {
-  constructor(message: string, data = {}, cause?: ErrorObject) {
-    super(message, data, cause, 'AssertionError')
+  constructor(message: string, data?: ErrorData) {
+    super(message, data, { name: 'AssertionError' })
   }
 }

package/src/error/error.model.ts

@@ -85,6 +85,14 @@ export interface ErrorData {
 }
 
 export interface HttpRequestErrorData extends ErrorData {
+  /**
+   * Actual `fetch` Response as it was returned.
+   * Note that not every Request has a Response, hence it's optional.
+   *
+   * Non-enumerable.
+   */
+  response?: Response
+
   requestUrl: string
   requestBaseUrl?: string
   requestMethod: HttpMethod