@naturalcycles/js-lib 14.104.0 → 14.105.0

package/dist/enum.util.d.ts

@@ -0,0 +1,55 @@
+import { NumberEnum, StringEnum } from './types';
+/**
+ * Returns all number keys of a number-enum.
+ */
+export declare function _numberEnumKeys(en: NumberEnum): string[];
+/**
+ * Returns all number values of a number-enum.
+ */
+export declare function _numberEnumValues(en: NumberEnum): number[];
+/**
+ * Returns all string keys of a string-enum.
+ */
+export declare function _stringEnumKeys(en: StringEnum): string[];
+/**
+ * Returns all string values of a string-enum.
+ */
+export declare function _stringEnumValues(en: StringEnum): string[];
+/**
+ * Returns all number-enum "entries", where entry is a tuple of [key, value],
+ * where key is a String key, value is a Number value, typed as Enum itself.
+ *
+ * Doesn't work on String-enums!
+ */
+export declare function _numberEnumEntries<T extends NumberEnum>(en: T): [k: string, v: T[keyof T]][];
+/**
+ * Returns all string-enum "entries", where entry is a tuple of [key, value],
+ * where key is a String key, value is a String value, typed as Enum itself.
+ *
+ * Doesn't work on Number-enums!
+ */
+export declare function _stringEnumEntries<T extends StringEnum>(en: T): [k: string, v: T[keyof T]][];
+/**
+ * Allows to return a Number enum value (typed as Enum itself) based on it's String key.
+ * e.g:
+ * const v = SomeEnum['stringValue']
+ * // v is of type SomeEnum, which is of type Number
+ *
+ * Throws if value is not found!
+ */
+export declare function _numberEnumInverse<T extends NumberEnum>(en: T, v: string): T[keyof T];
+/**
+ * _enumInverse, but allows to get/return undefined output.
+ */
+export declare function _numberEnumInverseNullable<T extends NumberEnum>(en: T, v: string | undefined): T[keyof T] | undefined;
+/**
+ * Takes number or string enum input, returns normalized Enum output.
+ * Only works for number enums.
+ *
+ * Throws if value is not found!
+ */
+export declare function _numberEnumNormalize<T extends NumberEnum>(en: T, v: string | number): T[keyof T];
+/**
+ * Same as _enumNormalize, but allows to return undefined values.
+ */
+export declare function _numberEnumNormalizeNullable<T extends NumberEnum>(en: T, v: string | number | undefined): T[keyof T] | undefined;

package/dist/enum.util.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._numberEnumNormalizeNullable = exports._numberEnumNormalize = exports._numberEnumInverseNullable = exports._numberEnumInverse = exports._stringEnumEntries = exports._numberEnumEntries = exports._stringEnumValues = exports._stringEnumKeys = exports._numberEnumValues = exports._numberEnumKeys = void 0;
+/**
+ * Returns all number keys of a number-enum.
+ */
+function _numberEnumKeys(en) {
+    return Object.values(en).filter(k => typeof k === 'string');
+}
+exports._numberEnumKeys = _numberEnumKeys;
+/**
+ * Returns all number values of a number-enum.
+ */
+function _numberEnumValues(en) {
+    return Object.values(en).filter(k => typeof k === 'number');
+}
+exports._numberEnumValues = _numberEnumValues;
+/**
+ * Returns all string keys of a string-enum.
+ */
+function _stringEnumKeys(en) {
+    return Object.keys(en);
+}
+exports._stringEnumKeys = _stringEnumKeys;
+/**
+ * Returns all string values of a string-enum.
+ */
+function _stringEnumValues(en) {
+    // filtering here is unnecessary, but works as a safety in case Number-enum is passed
+    return Object.values(en).filter(k => typeof k === 'string');
+}
+exports._stringEnumValues = _stringEnumValues;
+/**
+ * Returns all number-enum "entries", where entry is a tuple of [key, value],
+ * where key is a String key, value is a Number value, typed as Enum itself.
+ *
+ * Doesn't work on String-enums!
+ */
+function _numberEnumEntries(en) {
+    return Object.values(en)
+        .filter(k => typeof k === 'string')
+        .map(k => [k, en[k]]);
+}
+exports._numberEnumEntries = _numberEnumEntries;
+/**
+ * Returns all string-enum "entries", where entry is a tuple of [key, value],
+ * where key is a String key, value is a String value, typed as Enum itself.
+ *
+ * Doesn't work on Number-enums!
+ */
+function _stringEnumEntries(en) {
+    return Object.keys(en).map(k => [k, en[k]]);
+}
+exports._stringEnumEntries = _stringEnumEntries;
+/**
+ * Allows to return a Number enum value (typed as Enum itself) based on it's String key.
+ * e.g:
+ * const v = SomeEnum['stringValue']
+ * // v is of type SomeEnum, which is of type Number
+ *
+ * Throws if value is not found!
+ */
+function _numberEnumInverse(en, v) {
+    const r = en[v];
+    if (!r)
+        throw new Error(`enumInverse value not found for: ${v}`);
+    return r;
+}
+exports._numberEnumInverse = _numberEnumInverse;
+/**
+ * _enumInverse, but allows to get/return undefined output.
+ */
+function _numberEnumInverseNullable(en, v) {
+    return en[v];
+}
+exports._numberEnumInverseNullable = _numberEnumInverseNullable;
+/**
+ * Takes number or string enum input, returns normalized Enum output.
+ * Only works for number enums.
+ *
+ * Throws if value is not found!
+ */
+function _numberEnumNormalize(en, v) {
+    const r = _numberEnumNormalizeNullable(en, v);
+    if (!r || !en[r])
+        throw new Error(`enumNormalize value not found for: ${v}`);
+    return r;
+}
+exports._numberEnumNormalize = _numberEnumNormalize;
+/**
+ * Same as _enumNormalize, but allows to return undefined values.
+ */
+function _numberEnumNormalizeNullable(en, v) {
+    return typeof v === 'string' ? en[v] : v;
+}
+exports._numberEnumNormalizeNullable = _numberEnumNormalizeNullable;

package/dist/index.d.ts

@@ -16,6 +16,7 @@ export * from './decorators/retry.decorator';
 export * from './decorators/timeout.decorator';
 export * from './error/app.error';
 export * from './error/assert';
+export * from './enum.util';
 import { Admin401ErrorData, Admin403ErrorData, ErrorData, ErrorObject, HttpErrorData, HttpErrorResponse } from './error/error.model';
 export * from './error/error.util';
 import { ErrorMode } from './error/errorMode';
@@ -52,7 +53,7 @@ import { JsonStringifyFunction, StringifyAnyOptions, _stringifyAny } from './str
 export * from './time/time.util';
 export * from './is.util';
 import { Class, ConditionalExcept, ConditionalPick, Merge, Promisable, ReadonlyDeep, Simplify } from './typeFest';
-import { AsyncMapper, AsyncPredicate, BaseDBEntity, CreatedUpdated, CreatedUpdatedId, ObjectWithId, AnyObjectWithId, Saved, Unsaved, UnsavedId, BatchResult, InstanceId, IsoDate, IsoDateString, IsoDateTimeString, KeyValueTuple, Mapper, ObjectMapper, ObjectPredicate, Predicate, PromiseMap, AnyObject, AnyFunction, Reviver, SavedDBEntity, StringMap, UnixTimestampNumber, UnixTimestampMillisNumber, UnixTimestamp, Integer, ValueOf, ValuesOf, AbortableMapper, AbortableAsyncPredicate, AbortableAsyncMapper, AbortablePredicate, NullishValue, FalsyValue, END, SKIP, _noop, _objectKeys, _passNothingPredicate, _passthroughMapper, _passthroughPredicate, _passUndefinedMapper, _stringMapEntries, _stringMapValues } from './types';
+import { AsyncMapper, AsyncPredicate, BaseDBEntity, CreatedUpdated, CreatedUpdatedId, ObjectWithId, AnyObjectWithId, Saved, Unsaved, UnsavedId, BatchResult, InstanceId, IsoDate, IsoDateString, IsoDateTimeString, KeyValueTuple, Mapper, ObjectMapper, ObjectPredicate, Predicate, PromiseMap, AnyObject, AnyEnum, NumberEnum, StringEnum, AnyFunction, Reviver, SavedDBEntity, StringMap, UnixTimestampNumber, UnixTimestampMillisNumber, UnixTimestamp, Integer, ValueOf, ValuesOf, AbortableMapper, AbortableAsyncPredicate, AbortableAsyncMapper, AbortablePredicate, NullishValue, FalsyValue, END, SKIP, _noop, _objectKeys, _passNothingPredicate, _passthroughMapper, _passthroughPredicate, _passUndefinedMapper, _stringMapEntries, _stringMapValues } from './types';
 export * from './unit/size.util';
 import { is } from './vendor/is';
 import { CommonLogLevel, CommonLogFunction, CommonLogger, commonLoggerMinLevel, commonLoggerNoop, commonLogLevelNumber, commonLoggerPipe, commonLoggerPrefix, CommonLogWithLevelFunction, commonLoggerCreate } from './log/commonLogger';
@@ -69,5 +70,5 @@ import { LocalDateConfig, LocalDateFormatter, LocalDateUnit, LocalDateUnitStrict
 import { LocalTimeConfig, LocalTimeFormatter, LocalTimeUnit, LocalTimeComponents, ISODayOfWeek } from './datetime/localTime';
 import { DateIntervalConfig, DateIntervalString } from './datetime/dateInterval';
 import { TimeIntervalConfig, TimeIntervalString } from './datetime/timeInterval';
-export type { DateIntervalConfig, DateIntervalString, TimeIntervalConfig, TimeIntervalString, LocalDateConfig, LocalDateFormatter, LocalDateUnit, LocalDateUnitStrict, Inclusiveness, LocalTimeConfig, LocalTimeFormatter, LocalTimeUnit, ISODayOfWeek, LocalTimeComponents, AbortableMapper, AbortablePredicate, AbortableAsyncPredicate, AbortableAsyncMapper, PQueueCfg, MemoCache, AsyncMemoCache, PromiseDecoratorCfg, PromiseDecoratorResp, ErrorData, ErrorObject, HttpErrorData, HttpErrorResponse, Admin401ErrorData, Admin403ErrorData, StringMap, PromiseMap, AnyObject, AnyFunction, ValuesOf, ValueOf, KeyValueTuple, ObjectMapper, ObjectPredicate, InstanceId, IsoDate, IsoDateString, IsoDateTimeString, Reviver, FalsyValue, NullishValue, PMapOptions, Mapper, AsyncMapper, Predicate, AsyncPredicate, BatchResult, DeferredPromise, PRetryOptions, PTimeoutOptions, TryCatchOptions, StringifyAnyOptions, JsonStringifyFunction, Merge, ReadonlyDeep, Promisable, Simplify, ConditionalPick, ConditionalExcept, Class, UnixTimestampNumber, UnixTimestampMillisNumber, UnixTimestamp, Integer, BaseDBEntity, SavedDBEntity, Saved, Unsaved, UnsavedId, CreatedUpdated, CreatedUpdatedId, ObjectWithId, AnyObjectWithId, JsonSchema, JsonSchemaAny, JsonSchemaOneOf, JsonSchemaAllOf, JsonSchemaAnyOf, JsonSchemaNot, JsonSchemaRef, JsonSchemaConst, JsonSchemaEnum, JsonSchemaString, JsonSchemaNumber, JsonSchemaBoolean, JsonSchemaNull, JsonSchemaRootObject, JsonSchemaObject, JsonSchemaArray, JsonSchemaTuple, JsonSchemaBuilder, CommonLogLevel, CommonLogWithLevelFunction, CommonLogFunction, CommonLogger, };
+export type { DateIntervalConfig, DateIntervalString, TimeIntervalConfig, TimeIntervalString, LocalDateConfig, LocalDateFormatter, LocalDateUnit, LocalDateUnitStrict, Inclusiveness, LocalTimeConfig, LocalTimeFormatter, LocalTimeUnit, ISODayOfWeek, LocalTimeComponents, AbortableMapper, AbortablePredicate, AbortableAsyncPredicate, AbortableAsyncMapper, PQueueCfg, MemoCache, AsyncMemoCache, PromiseDecoratorCfg, PromiseDecoratorResp, ErrorData, ErrorObject, HttpErrorData, HttpErrorResponse, Admin401ErrorData, Admin403ErrorData, StringMap, PromiseMap, AnyObject, AnyEnum, NumberEnum, StringEnum, AnyFunction, ValuesOf, ValueOf, KeyValueTuple, ObjectMapper, ObjectPredicate, InstanceId, IsoDate, IsoDateString, IsoDateTimeString, Reviver, FalsyValue, NullishValue, PMapOptions, Mapper, AsyncMapper, Predicate, AsyncPredicate, BatchResult, DeferredPromise, PRetryOptions, PTimeoutOptions, TryCatchOptions, StringifyAnyOptions, JsonStringifyFunction, Merge, ReadonlyDeep, Promisable, Simplify, ConditionalPick, ConditionalExcept, Class, UnixTimestampNumber, UnixTimestampMillisNumber, UnixTimestamp, Integer, BaseDBEntity, SavedDBEntity, Saved, Unsaved, UnsavedId, CreatedUpdated, CreatedUpdatedId, ObjectWithId, AnyObjectWithId, JsonSchema, JsonSchemaAny, JsonSchemaOneOf, JsonSchemaAllOf, JsonSchemaAnyOf, JsonSchemaNot, JsonSchemaRef, JsonSchemaConst, JsonSchemaEnum, JsonSchemaString, JsonSchemaNumber, JsonSchemaBoolean, JsonSchemaNull, JsonSchemaRootObject, JsonSchemaObject, JsonSchemaArray, JsonSchemaTuple, JsonSchemaBuilder, CommonLogLevel, CommonLogWithLevelFunction, CommonLogFunction, CommonLogger, };
 export { is, _createPromiseDecorator, _stringMapValues, _stringMapEntries, _objectKeys, pMap, _passthroughMapper, _passUndefinedMapper, _passthroughPredicate, _passNothingPredicate, _noop, ErrorMode, pDefer, AggregatedError, pRetry, pRetryFn, pTimeout, pTimeoutFn, _tryCatch, _TryCatch, _stringifyAny, jsonSchema, JsonSchemaAnyBuilder, commonLoggerMinLevel, commonLoggerNoop, commonLogLevelNumber, commonLoggerPipe, commonLoggerPrefix, commonLoggerCreate, PQueue, END, SKIP, };

package/dist/index.js

@@ -20,6 +20,7 @@ tslib_1.__exportStar(require("./decorators/retry.decorator"), exports);
 tslib_1.__exportStar(require("./decorators/timeout.decorator"), exports);
 tslib_1.__exportStar(require("./error/app.error"), exports);
 tslib_1.__exportStar(require("./error/assert"), exports);
+tslib_1.__exportStar(require("./enum.util"), exports);
 tslib_1.__exportStar(require("./error/error.util"), exports);
 const errorMode_1 = require("./error/errorMode");
 Object.defineProperty(exports, "ErrorMode", { enumerable: true, get: function () { return errorMode_1.ErrorMode; } });

package/dist/object/object.util.js

@@ -330,6 +330,7 @@ function _set(obj, path, value) {
             a[c]
         : // No: create the key. Is the next key a potential array-index?
             (a[c] =
+                // @ts-ignore
                 // eslint-disable-next-line
                 Math.abs(path[i + 1]) >> 0 === +path[i + 1]
                     ? [] // Yes: assign a new array object

package/dist/promise/pProps.js

@@ -17,6 +17,8 @@ exports.pProps = void 0;
  */
 async function pProps(input) {
     const keys = Object.keys(input);
+    // `as any` here is added to make it compile when `noUncheckedIndexedAccess` is false
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
     return Object.fromEntries((await Promise.all(Object.values(input))).map((v, i) => [keys[i], v]));
 }
 exports.pProps = pProps;

package/dist/string/url.util.js

@@ -17,7 +17,7 @@ exports._parseQueryString = void 0;
 function _parseQueryString(search) {
     const qs = {};
     search
-        .substr(search[0] === '?' ? 1 : 0)
+        .slice(search[0] === '?' ? 1 : 0)
         .split('&')
         .forEach(p => {
         const [k, v] = p.split('=');

package/dist/types.d.ts

@@ -20,6 +20,9 @@ export interface PromiseMap {
  * Because `object` type is not safe/recommended to be used (e.g discouraged by eslint-typescript due to: https://github.com/microsoft/TypeScript/issues/21732)
  */
 export declare type AnyObject = Record<string, any>;
+export declare type AnyEnum = NumberEnum;
+export declare type NumberEnum = Record<string, number | string>;
+export declare type StringEnum = Record<string, string>;
 export interface CreatedUpdated {
     created: number;
     updated: number;

package/dist-esm/datetime/localTime.js

@@ -179,10 +179,11 @@ export class LocalTime {
         return v === undefined ? this.get('second') : this.set('second', v);
     }
     setComponents(c, mutate = false) {
+        var _a;
         const d = mutate ? this.$date : new Date(this.$date);
         // Year, month and day set all-at-once, to avoid 30/31 (and 28/29) mishap
         if (c.day || c.month !== undefined || c.year !== undefined) {
-            d.setFullYear(c.year ?? d.getFullYear(), c.month ? c.month - 1 : d.getMonth(), c.day || d.getDate());
+            d.setFullYear((_a = c.year) !== null && _a !== void 0 ? _a : d.getFullYear(), c.month ? c.month - 1 : d.getMonth(), c.day || d.getDate());
         }
         if (c.hour !== undefined) {
             d.setHours(c.hour);

package/dist-esm/decorators/createPromiseDecorator.js

@@ -19,6 +19,7 @@ export function _createPromiseDecorator(cfg, decoratorParams = {}) {
         const key = String(propertyKey);
         const methodSignature = _getTargetMethodSignature(target, key);
         pd.value = async function (...args) {
+            var _a, _b;
             // console.log(`@${cfg.decoratorName} called inside function`)
             const started = Date.now();
             try {
@@ -46,12 +47,9 @@ export function _createPromiseDecorator(cfg, decoratorParams = {}) {
                     started,
                 };
                 if (cfg.thenFn) {
-                    res = cfg.thenFn({
-                        ...resp,
-                        res,
-                    });
+                    res = cfg.thenFn(Object.assign(Object.assign({}, resp), { res }));
                 }
-                cfg.finallyFn?.(resp);
+                (_a = cfg.finallyFn) === null || _a === void 0 ? void 0 : _a.call(cfg, resp);
                 return res;
             }
             catch (err) {
@@ -66,13 +64,10 @@ export function _createPromiseDecorator(cfg, decoratorParams = {}) {
                 };
                 let handled = false;
                 if (cfg.catchFn) {
-                    cfg.catchFn({
-                        ...resp,
-                        err,
-                    });
+                    cfg.catchFn(Object.assign(Object.assign({}, resp), { err }));
                     handled = true;
                 }
-                cfg.finallyFn?.(resp);
+                (_b = cfg.finallyFn) === null || _b === void 0 ? void 0 : _b.call(cfg, resp);
                 if (!handled) {
                     throw err; // rethrow
                 }

package/dist-esm/decorators/debounce.js

@@ -105,10 +105,5 @@ export function _debounce(func, wait, opt = {}) {
     return debounced;
 }
 export function _throttle(func, wait, opt = {}) {
-    return _debounce(func, wait, {
-        leading: true,
-        trailing: true,
-        ...opt,
-        maxWait: wait,
-    });
+    return _debounce(func, wait, Object.assign(Object.assign({ leading: true, trailing: true }, opt), { maxWait: wait }));
 }

package/dist-esm/enum.util.js

@@ -0,0 +1,83 @@
+/**
+ * Returns all number keys of a number-enum.
+ */
+export function _numberEnumKeys(en) {
+    return Object.values(en).filter(k => typeof k === 'string');
+}
+/**
+ * Returns all number values of a number-enum.
+ */
+export function _numberEnumValues(en) {
+    return Object.values(en).filter(k => typeof k === 'number');
+}
+/**
+ * Returns all string keys of a string-enum.
+ */
+export function _stringEnumKeys(en) {
+    return Object.keys(en);
+}
+/**
+ * Returns all string values of a string-enum.
+ */
+export function _stringEnumValues(en) {
+    // filtering here is unnecessary, but works as a safety in case Number-enum is passed
+    return Object.values(en).filter(k => typeof k === 'string');
+}
+/**
+ * Returns all number-enum "entries", where entry is a tuple of [key, value],
+ * where key is a String key, value is a Number value, typed as Enum itself.
+ *
+ * Doesn't work on String-enums!
+ */
+export function _numberEnumEntries(en) {
+    return Object.values(en)
+        .filter(k => typeof k === 'string')
+        .map(k => [k, en[k]]);
+}
+/**
+ * Returns all string-enum "entries", where entry is a tuple of [key, value],
+ * where key is a String key, value is a String value, typed as Enum itself.
+ *
+ * Doesn't work on Number-enums!
+ */
+export function _stringEnumEntries(en) {
+    return Object.keys(en).map(k => [k, en[k]]);
+}
+/**
+ * Allows to return a Number enum value (typed as Enum itself) based on it's String key.
+ * e.g:
+ * const v = SomeEnum['stringValue']
+ * // v is of type SomeEnum, which is of type Number
+ *
+ * Throws if value is not found!
+ */
+export function _numberEnumInverse(en, v) {
+    const r = en[v];
+    if (!r)
+        throw new Error(`enumInverse value not found for: ${v}`);
+    return r;
+}
+/**
+ * _enumInverse, but allows to get/return undefined output.
+ */
+export function _numberEnumInverseNullable(en, v) {
+    return en[v];
+}
+/**
+ * Takes number or string enum input, returns normalized Enum output.
+ * Only works for number enums.
+ *
+ * Throws if value is not found!
+ */
+export function _numberEnumNormalize(en, v) {
+    const r = _numberEnumNormalizeNullable(en, v);
+    if (!r || !en[r])
+        throw new Error(`enumNormalize value not found for: ${v}`);
+    return r;
+}
+/**
+ * Same as _enumNormalize, but allows to return undefined values.
+ */
+export function _numberEnumNormalizeNullable(en, v) {
+    return typeof v === 'string' ? en[v] : v;
+}

package/dist-esm/error/assert.js

@@ -18,10 +18,7 @@ import { AppError } from './app.error';
 export function _assert(condition, // will be evaluated as Boolean
 message, errorData) {
     if (!condition) {
-        throw new AssertionError(message || 'see stacktrace', {
-            userFriendly: true,
-            ...errorData,
-        });
+        throw new AssertionError(message || 'see stacktrace', Object.assign({ userFriendly: true }, errorData));
     }
 }
 /**
@@ -39,10 +36,7 @@ export function _assertEquals(actual, expected, message, errorData) {
         ]
             .filter(Boolean)
             .join('\n');
-        throw new AssertionError(msg, {
-            userFriendly: true,
-            ...errorData,
-        });
+        throw new AssertionError(msg, Object.assign({ userFriendly: true }, errorData));
     }
 }
 /**
@@ -60,10 +54,7 @@ export function _assertDeepEquals(actual, expected, message, errorData) {
         ]
             .filter(Boolean)
             .join('\n');
-        throw new AssertionError(msg, {
-            userFriendly: true,
-            ...errorData,
-        });
+        throw new AssertionError(msg, Object.assign({ userFriendly: true }, errorData));
     }
 }
 export function _assertIsError(err, message) {

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

@@ -21,8 +21,9 @@ export function _anyToError(o, errorClass = Error, opt) {
  * Objects (not Errors) get converted to prettified JSON string (via `_stringifyAny`).
  */
 export function _anyToErrorObject(o, opt) {
+    var _a;
     if (o instanceof Error) {
-        return _errorToErrorObject(o, opt?.includeErrorStack ?? true);
+        return _errorToErrorObject(o, (_a = opt === null || opt === void 0 ? void 0 : opt.includeErrorStack) !== null && _a !== void 0 ? _a : true);
     }
     o = _jsonParseIfPossible(o);
     if (_isHttpErrorResponse(o)) {
@@ -35,10 +36,7 @@ export function _anyToErrorObject(o, opt) {
     // so, fair to return `data: {}` in the end
     // Also we're sure it includes no "error name", e.g no `Error: ...`,
     // so, fair to include `name: 'Error'`
-    const message = _stringifyAny(o, {
-        includeErrorData: true,
-        ...opt,
-    });
+    const message = _stringifyAny(o, Object.assign({ includeErrorData: true }, opt));
     return {
         name: 'Error',
         message,
@@ -49,7 +47,7 @@ export function _errorToErrorObject(e, includeErrorStack = true) {
     const obj = {
         name: e.name,
         message: e.message,
-        data: { ...e.data }, // empty by default
+        data: Object.assign({}, e.data), // empty by default
     };
     if (includeErrorStack) {
         obj.stack = e.stack;
@@ -83,13 +81,14 @@ export function _errorObjectToError(o, errorClass = Error) {
     return err;
 }
 export function _isHttpErrorResponse(o) {
-    return _isHttpErrorObject(o?.error);
+    return _isHttpErrorObject(o === null || o === void 0 ? void 0 : o.error);
 }
 export function _isHttpErrorObject(o) {
+    var _a;
     return (!!o &&
         typeof o.name === 'string' &&
         typeof o.message === 'string' &&
-        typeof o.data?.httpStatusCode === 'number');
+        typeof ((_a = o.data) === null || _a === void 0 ? void 0 : _a.httpStatusCode) === 'number');
 }
 /**
  * Note: any instance of AppError is also automatically an ErrorObject

package/dist-esm/error/tryCatch.js

@@ -29,7 +29,7 @@ export function _tryCatch(fn, opt = {}) {
                 try {
                     return await onError(_anyToError(err)); // eslint-disable-line @typescript-eslint/return-await
                 }
-                catch { }
+                catch (_a) { }
             }
             // returns undefined, but doesn't rethrow
         }

package/dist-esm/index.js

@@ -15,6 +15,7 @@ export * from './decorators/retry.decorator';
 export * from './decorators/timeout.decorator';
 export * from './error/app.error';
 export * from './error/assert';
+export * from './enum.util';
 export * from './error/error.util';
 import { ErrorMode } from './error/errorMode';
 export * from './error/http.error';

package/dist-esm/json-schema/jsonSchema.util.js

@@ -6,6 +6,7 @@ import { _filterNullishValues } from '../object/object.util';
  * API similar to Object.assign(s1, s2)
  */
 export function mergeJsonSchemaObjects(s1, s2) {
+    var _a, _b;
     // Merge `properties`
     Object.entries(s2.properties).forEach(([k, v]) => {
         ;
@@ -17,8 +18,8 @@ export function mergeJsonSchemaObjects(s1, s2) {
         s1.patternProperties[k] = v;
     });
     s1.propertyNames = s2.propertyNames || s1.propertyNames;
-    s1.minProperties = s2.minProperties ?? s1.minProperties;
-    s1.maxProperties = s2.maxProperties ?? s1.maxProperties;
+    s1.minProperties = (_a = s2.minProperties) !== null && _a !== void 0 ? _a : s1.minProperties;
+    s1.maxProperties = (_b = s2.maxProperties) !== null && _b !== void 0 ? _b : s1.maxProperties;
     // Merge `required`
     s1.required.push(...s2.required);
     s1.required = _uniq(s1.required).sort();

package/dist-esm/json-schema/jsonSchemaBuilder.js

@@ -250,11 +250,12 @@ export class JsonSchemaStringBuilder extends JsonSchemaAnyBuilder {
         return this;
     }
     transformModify(t, add) {
+        var _a;
         if (add) {
             this.schema.transform = _uniq([...(this.schema.transform || []), t]);
         }
         else {
-            this.schema.transform = this.schema.transform?.filter(s => s !== t);
+            this.schema.transform = (_a = this.schema.transform) === null || _a === void 0 ? void 0 : _a.filter(s => s !== t);
         }
         return this;
     }

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

@@ -14,7 +14,7 @@ export function _average(values) {
  * Same as _average, but safely returns null if input array is empty or nullish.
  */
 export function _averageOrNull(values) {
-    return values?.length ? values.reduce((a, b) => a + b) / values.length : null;
+    return (values === null || values === void 0 ? void 0 : values.length) ? values.reduce((a, b) => a + b) / values.length : null;
 }
 /**
  * valuesArray and weightsArray length is expected to be the same.

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

@@ -29,7 +29,7 @@ export function _omit(obj, props, mutate = false) {
     return props.reduce((r, prop) => {
         delete r[prop];
         return r;
-    }, mutate ? obj : { ...obj });
+    }, mutate ? obj : Object.assign({}, obj));
 }
 /**
  * Returns object with filtered keys from `props` array.
@@ -76,7 +76,7 @@ export function _filterObject(obj, predicate, mutate = false) {
         if (!predicate(k, r[k], obj))
             delete r[k];
         return r;
-    }, mutate ? obj : { ...obj });
+    }, mutate ? obj : Object.assign({}, obj));
 }
 /**
  * var users = {
@@ -137,7 +137,8 @@ export function _mapObject(obj, mapper) {
     }, {});
 }
 export function _findKeyByValue(obj, v) {
-    return Object.entries(obj).find(([_, value]) => value === v)?.[0];
+    var _a;
+    return (_a = Object.entries(obj).find(([_, value]) => value === v)) === null || _a === void 0 ? void 0 : _a[0];
 }
 export function _objectNullValuesToUndefined(obj, mutate = false) {
     return _mapValues(obj, (_k, v) => (v === null ? undefined : v), mutate);
@@ -305,6 +306,7 @@ export function _set(obj, path, value) {
             a[c]
         : // No: create the key. Is the next key a potential array-index?
             (a[c] =
+                // @ts-ignore
                 // eslint-disable-next-line
                 Math.abs(path[i + 1]) >> 0 === +path[i + 1]
                     ? [] // Yes: assign a new array object

package/dist-esm/promise/pMap.js

@@ -6,6 +6,7 @@ Improvements:
 - Included Typescript typings (no need for @types/p-map)
 - Compatible with pProps (that had typings issues)
  */
+import { __asyncValues } from "tslib";
 import { END, ErrorMode, SKIP } from '..';
 import { AggregatedError } from './AggregatedError';
 /**
@@ -35,6 +36,7 @@ import { AggregatedError } from './AggregatedError';
  * })();
  */
 export async function pMap(iterable, mapper, opt = {}) {
+    var e_1, _a;
     const ret = [];
     // const iterator = iterable[Symbol.iterator]()
     const items = [...iterable];
@@ -48,23 +50,33 @@ export async function pMap(iterable, mapper, opt = {}) {
     let currentIndex = 0;
     // Special cases that are able to preserve async stack traces
     if (concurrency === 1) {
-        // Special case for concurrency == 1
-        for await (const item of items) {
-            try {
-                const r = await mapper(item, currentIndex++);
-                if (r === END)
-                    break;
-                if (r !== SKIP)
-                    ret.push(r);
-            }
-            catch (err) {
-                if (errorMode === ErrorMode.THROW_IMMEDIATELY)
-                    throw err;
-                if (errorMode === ErrorMode.THROW_AGGREGATED) {
-                    errors.push(err);
+        try {
+            // Special case for concurrency == 1
+            for (var items_1 = __asyncValues(items), items_1_1; items_1_1 = await items_1.next(), !items_1_1.done;) {
+                const item = items_1_1.value;
+                try {
+                    const r = await mapper(item, currentIndex++);
+                    if (r === END)
+                        break;
+                    if (r !== SKIP)
+                        ret.push(r);
                 }
-                // otherwise, suppress completely
+                catch (err) {
+                    if (errorMode === ErrorMode.THROW_IMMEDIATELY)
+                        throw err;
+                    if (errorMode === ErrorMode.THROW_AGGREGATED) {
+                        errors.push(err);
+                    }
+                    // otherwise, suppress completely
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (items_1_1 && !items_1_1.done && (_a = items_1.return)) await _a.call(items_1);
             }
+            finally { if (e_1) throw e_1.error; }
         }
         if (errors.length) {
             throw new AggregatedError(errors, ret);

package/dist-esm/promise/pProps.js

@@ -14,5 +14,7 @@
  */
 export async function pProps(input) {
     const keys = Object.keys(input);
+    // `as any` here is added to make it compile when `noUncheckedIndexedAccess` is false
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
     return Object.fromEntries((await Promise.all(Object.values(input))).map((v, i) => [keys[i], v]));
 }

package/dist-esm/promise/pQueue.js

@@ -13,14 +13,9 @@ export class PQueue {
         this.inFlight = 0;
         this.queue = [];
         this.onIdleListeners = [];
-        this.cfg = {
+        this.cfg = Object.assign({ 
             // concurrency: Number.MAX_SAFE_INTEGER,
-            errorMode: ErrorMode.THROW_IMMEDIATELY,
-            logger: console,
-            debug: false,
-            resolveOn: 'finish',
-            ...cfg,
-        };
+            errorMode: ErrorMode.THROW_IMMEDIATELY, logger: console, debug: false, resolveOn: 'finish' }, cfg);
         if (!cfg.debug) {
             this.debug = () => { };
         }

package/dist-esm/promise/pRetry.js

@@ -72,10 +72,7 @@ export async function pRetry(fn, opt = {}) {
                         });
                     }
                     ;
-                    err.data = {
-                        ...err.data,
-                        ...opt.errorData,
-                    };
+                    err.data = Object.assign(Object.assign({}, err.data), opt.errorData);
                     reject(err);
                 }
                 else {

package/dist-esm/promise/pTimeout.js

@@ -32,10 +32,7 @@ export async function pTimeout(promise, opt) {
                 catch (err) {
                     if (fakeError)
                         err.stack = fakeError.stack; // keep original stack
-                    err.data = {
-                        ...err.data,
-                        ...opt.errorData,
-                    };
+                    err.data = Object.assign(Object.assign({}, err.data), opt.errorData);
                     reject(err);
                 }
                 return;

package/dist-esm/string/json.util.js

@@ -10,7 +10,7 @@ export function _jsonParseIfPossible(obj, reviver) {
         try {
             return JSON.parse(obj, reviver);
         }
-        catch { }
+        catch (_a) { }
     }
     return obj;
 }

package/dist-esm/string/safeJsonStringify.js

@@ -8,7 +8,7 @@ export function _safeJsonStringify(obj, replacer, spaces, cycleReplacer) {
         // Try native first (as it's ~3 times faster)
         return JSON.stringify(obj, replacer, spaces);
     }
-    catch {
+    catch (_a) {
         // Native failed - resort to the "safe" serializer
         return JSON.stringify(obj, serializer(replacer, cycleReplacer), spaces);
     }

package/dist-esm/string/stringifyAny.js

@@ -85,7 +85,7 @@ export function _stringifyAny(obj, opt = {}) {
             const { stringifyFn = _safeJsonStringify } = opt;
             s = stringifyFn(obj, undefined, 2);
         }
-        catch {
+        catch (_a) {
             s = String(obj); // fallback
         }
     }

package/dist-esm/string/url.util.js

@@ -14,7 +14,7 @@
 export function _parseQueryString(search) {
     const qs = {};
     search
-        .substr(search[0] === '?' ? 1 : 0)
+        .slice(search[0] === '?' ? 1 : 0)
         .split('&')
         .forEach(p => {
         const [k, v] = p.split('=');

package/dist-esm/vendor/is.js

@@ -138,15 +138,15 @@ is.array = (value, assertion) => {
     }
     return value.every(assertion);
 };
-is.buffer = (value) => value?.constructor?.isBuffer?.(value) ?? false;
+is.buffer = (value) => { var _a, _b, _c; return (_c = (_b = (_a = value === null || value === void 0 ? void 0 : value.constructor) === null || _a === void 0 ? void 0 : _a.isBuffer) === null || _b === void 0 ? void 0 : _b.call(_a, value)) !== null && _c !== void 0 ? _c : false; };
 is.nullOrUndefined = (value) => is.null_(value) || is.undefined(value);
 is.object = (value) => !is.null_(value) && (typeof value === 'object' || is.function_(value));
-is.iterable = (value) => is.function_(value?.[Symbol.iterator]);
-is.asyncIterable = (value) => is.function_(value?.[Symbol.asyncIterator]);
+is.iterable = (value) => is.function_(value === null || value === void 0 ? void 0 : value[Symbol.iterator]);
+is.asyncIterable = (value) => is.function_(value === null || value === void 0 ? void 0 : value[Symbol.asyncIterator]);
 is.generator = (value) => is.iterable(value) && is.function_(value.next) && is.function_(value.throw);
 is.asyncGenerator = (value) => is.asyncIterable(value) && is.function_(value.next) && is.function_(value.throw);
 is.nativePromise = (value) => isObjectOfType('Promise')(value);
-const hasPromiseAPI = (value) => is.function_(value?.then) && is.function_(value?.catch);
+const hasPromiseAPI = (value) => is.function_(value === null || value === void 0 ? void 0 : value.then) && is.function_(value === null || value === void 0 ? void 0 : value.catch);
 is.promise = (value) => is.nativePromise(value) || hasPromiseAPI(value);
 is.generatorFunction = isObjectOfType('GeneratorFunction');
 is.asyncGeneratorFunction = (value) => getObjectType(value) === 'AsyncGeneratorFunction';
@@ -184,7 +184,7 @@ is.urlString = (value) => {
         new URL(value); // eslint-disable-line no-new
         return true;
     }
-    catch {
+    catch (_a) {
         return false;
     }
 };
@@ -235,13 +235,14 @@ is.domElement = (value) => {
         DOM_PROPERTIES_TO_CHECK.every(property => property in value));
 };
 is.observable = (value) => {
+    var _a, _b, _c, _d;
     if (!value) {
         return false;
     }
-    if (value === value[Symbol.observable]?.()) {
+    if (value === ((_b = (_a = value)[Symbol.observable]) === null || _b === void 0 ? void 0 : _b.call(_a))) {
         return true;
     }
-    if (value === value['@@observable']?.()) {
+    if (value === ((_d = (_c = value)['@@observable']) === null || _d === void 0 ? void 0 : _d.call(_c))) {
         return true;
     }
     return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@naturalcycles/js-lib",
-  "version": "14.104.0",
+  "version": "14.105.0",
   "scripts": {
     "prepare": "husky install",
     "build-prod": "build-prod-esm-cjs",
@@ -36,10 +36,6 @@
   "module": "dist-esm/index.js",
   "types": "dist/index.d.ts",
   "sideEffects": false,
-  "exports": {
-    "import": "./dist-esm/index.js",
-    "require": "./dist/index.js"
-  },
   "engines": {
     "node": ">=14.15.0"
   },

package/src/enum.util.ts

@@ -0,0 +1,98 @@
+import { NumberEnum, StringEnum } from './types'
+
+/**
+ * Returns all number keys of a number-enum.
+ */
+export function _numberEnumKeys(en: NumberEnum): string[] {
+  return Object.values(en).filter(k => typeof k === 'string') as string[]
+}
+
+/**
+ * Returns all number values of a number-enum.
+ */
+export function _numberEnumValues(en: NumberEnum): number[] {
+  return Object.values(en).filter(k => typeof k === 'number') as number[]
+}
+
+/**
+ * Returns all string keys of a string-enum.
+ */
+export function _stringEnumKeys(en: StringEnum): string[] {
+  return Object.keys(en)
+}
+
+/**
+ * Returns all string values of a string-enum.
+ */
+export function _stringEnumValues(en: StringEnum): string[] {
+  // filtering here is unnecessary, but works as a safety in case Number-enum is passed
+  return Object.values(en).filter(k => typeof k === 'string')
+}
+
+/**
+ * Returns all number-enum "entries", where entry is a tuple of [key, value],
+ * where key is a String key, value is a Number value, typed as Enum itself.
+ *
+ * Doesn't work on String-enums!
+ */
+export function _numberEnumEntries<T extends NumberEnum>(en: T): [k: string, v: T[keyof T]][] {
+  return Object.values(en)
+    .filter(k => typeof k === 'string')
+    .map(k => [k, en[k]]) as any
+}
+
+/**
+ * Returns all string-enum "entries", where entry is a tuple of [key, value],
+ * where key is a String key, value is a String value, typed as Enum itself.
+ *
+ * Doesn't work on Number-enums!
+ */
+export function _stringEnumEntries<T extends StringEnum>(en: T): [k: string, v: T[keyof T]][] {
+  return Object.keys(en).map(k => [k, en[k]]) as any
+}
+
+/**
+ * Allows to return a Number enum value (typed as Enum itself) based on it's String key.
+ * e.g:
+ * const v = SomeEnum['stringValue']
+ * // v is of type SomeEnum, which is of type Number
+ *
+ * Throws if value is not found!
+ */
+export function _numberEnumInverse<T extends NumberEnum>(en: T, v: string): T[keyof T] {
+  const r = en[v as keyof T] as any
+  if (!r) throw new Error(`enumInverse value not found for: ${v}`)
+  return r
+}
+
+/**
+ * _enumInverse, but allows to get/return undefined output.
+ */
+export function _numberEnumInverseNullable<T extends NumberEnum>(
+  en: T,
+  v: string | undefined,
+): T[keyof T] | undefined {
+  return en[v as keyof T]
+}
+
+/**
+ * Takes number or string enum input, returns normalized Enum output.
+ * Only works for number enums.
+ *
+ * Throws if value is not found!
+ */
+export function _numberEnumNormalize<T extends NumberEnum>(en: T, v: string | number): T[keyof T] {
+  const r = _numberEnumNormalizeNullable(en, v)
+  if (!r || !en[r as keyof T]) throw new Error(`enumNormalize value not found for: ${v}`)
+  return r
+}
+
+/**
+ * Same as _enumNormalize, but allows to return undefined values.
+ */
+export function _numberEnumNormalizeNullable<T extends NumberEnum>(
+  en: T,
+  v: string | number | undefined,
+): T[keyof T] | undefined {
+  return typeof v === 'string' ? en[v as keyof T] : (v as any)
+}

package/src/index.ts

@@ -20,6 +20,7 @@ export * from './decorators/retry.decorator'
 export * from './decorators/timeout.decorator'
 export * from './error/app.error'
 export * from './error/assert'
+export * from './enum.util'
 import {
   Admin401ErrorData,
   Admin403ErrorData,
@@ -117,6 +118,9 @@ import {
   Predicate,
   PromiseMap,
   AnyObject,
+  AnyEnum,
+  NumberEnum,
+  StringEnum,
   AnyFunction,
   Reviver,
   SavedDBEntity,
@@ -217,6 +221,9 @@ export type {
   StringMap,
   PromiseMap,
   AnyObject,
+  AnyEnum,
+  NumberEnum,
+  StringEnum,
   AnyFunction,
   ValuesOf,
   ValueOf,

package/src/object/object.util.ts

@@ -125,7 +125,7 @@ export function _mapValues<T extends AnyObject, OUT = T>(
   mutate = false,
 ): OUT {
   return Object.entries(obj).reduce((map, [k, v]) => {
-    map[k] = mapper(k, v, obj)
+    map[k as keyof OUT] = mapper(k, v, obj)
     return map
   }, (mutate ? obj : {}) as OUT)
 }
@@ -142,9 +142,9 @@ export function _mapKeys<T extends AnyObject>(
 ): StringMap<T[keyof T]> {
   // eslint-disable-next-line unicorn/prefer-object-from-entries
   return Object.entries(obj).reduce((map, [k, v]) => {
-    map[mapper(k, v, obj)] = v
+    map[mapper(k, v, obj) as keyof T] = v
     return map
-  }, {})
+  }, {} as T)
 }
 
 /**
@@ -299,7 +299,7 @@ export function _unset<T extends AnyObject>(obj: T, prop: string): void {
 export function _invert<T extends AnyObject>(o: T): { [k in ValueOf<T>]: keyof T | undefined } {
   const inv = {} as { [k in ValueOf<T>]: keyof T }
   Object.keys(o).forEach(k => {
-    inv[o[k]] = k
+    inv[o[k] as ValueOf<T>] = k
   })
   return inv
 }
@@ -365,6 +365,7 @@ export function _set<IN extends AnyObject, OUT = IN>(
           a[c]
         : // No: create the key. Is the next key a potential array-index?
           (a[c] =
+            // @ts-ignore
             // eslint-disable-next-line
             Math.abs(path[i + 1]) >> 0 === +path[i + 1]
               ? [] // Yes: assign a new array object

package/src/object/sortObjectDeep.ts

@@ -16,7 +16,7 @@ export function _sortObjectDeep<T>(o: T): T {
     Object.keys(o)
       .sort((a, b) => a.localeCompare(b))
       .forEach(k => {
-        out[k] = _sortObjectDeep(o[k])
+        out[k as keyof T] = _sortObjectDeep(o[k as keyof T])
       })
 
     return out

package/src/promise/pProps.ts

@@ -16,5 +16,9 @@ export async function pProps<T>(input: { [K in keyof T]: T[K] | Promise<T[K]> })
   [K in keyof T]: Awaited<T[K]>
 }> {
   const keys = Object.keys(input)
-  return Object.fromEntries((await Promise.all(Object.values(input))).map((v, i) => [keys[i], v]))
+  // `as any` here is added to make it compile when `noUncheckedIndexedAccess` is false
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+  return Object.fromEntries(
+    (await Promise.all(Object.values(input))).map((v, i) => [keys[i], v]),
+  ) as any
 }

package/src/string/url.util.ts

@@ -14,9 +14,9 @@ import { StringMap } from '../types'
  * Goal of this function is to produce exactly same output as URLSearchParams would.
  */
 export function _parseQueryString(search: string): StringMap {
-  const qs = {}
+  const qs: StringMap = {}
   search
-    .substr(search[0] === '?' ? 1 : 0)
+    .slice(search[0] === '?' ? 1 : 0)
     .split('&')
     .forEach(p => {
       const [k, v] = p.split('=')

package/src/types.ts

@@ -24,6 +24,10 @@ export interface PromiseMap {
  */
 export type AnyObject = Record<string, any>
 
+export type AnyEnum = NumberEnum
+export type NumberEnum = Record<string, number | string>
+export type StringEnum = Record<string, string>
+
 export interface CreatedUpdated {
   created: number
   updated: number