@bitfiber/utils 1.1.1 → 1.1.2

package/dist/types/obj/map-obj/map-obj.d.ts

@@ -1,8 +1,8 @@
-import { Obj, ValueUnion } from '../../common';
-/**
- * Returns a new object, which has the mapped values of object fields
- * @param obj - any object
- * @param handler - function called for each field
- */
-export declare function mapObj<T extends Obj, K extends keyof T, R>(obj: T, handler: (value: ValueUnion<T>, key: K, obj: T) => R): Record<K, R>;
+import { Obj, ValueUnion } from '../../common';
+/**
+ * Returns a new object, which has the mapped values of object fields
+ * @param obj - any object
+ * @param handler - function called for each field
+ */
+export declare function mapObj<T extends Obj, K extends keyof T, R>(obj: T, handler: (value: ValueUnion<T>, key: K, obj: T) => R): Record<K, R>;
 //# sourceMappingURL=map-obj.d.ts.map

package/dist/types/obj/map-obj-to-arr/map-obj-to-arr.d.ts

@@ -1,8 +1,8 @@
-import { Obj, ValueUnion } from '../../common';
-/**
- * Returns an array, which has the mapped values of object fields
- * @param obj - any object
- * @param handler - function called for each field
- */
-export declare function mapObjToArr<T extends Obj, K extends keyof T, R>(obj: T, handler: (value: ValueUnion<T>, key: K, obj: T) => R): R[];
+import { Obj, ValueUnion } from '../../common';
+/**
+ * Returns an array, which has the mapped values of object fields
+ * @param obj - any object
+ * @param handler - function called for each field
+ */
+export declare function mapObjToArr<T extends Obj, K extends keyof T, R>(obj: T, handler: (value: ValueUnion<T>, key: K, obj: T) => R): R[];
 //# sourceMappingURL=map-obj-to-arr.d.ts.map

package/dist/types/obj/values/values.d.ts

@@ -1,7 +1,7 @@
-import { Obj } from '../../common';
-/**
- * Returns an array of values for each object's own enumerable property
- * @param obj - any object
- */
-export declare function values<T>(obj: Obj<T>): T[];
+import { Obj } from '../../common';
+/**
+ * Returns an array of values for each object's own enumerable property
+ * @param obj - any object
+ */
+export declare function values<T>(obj: Obj<T>): T[];
 //# sourceMappingURL=values.d.ts.map

package/dist/types/str/index.d.ts

@@ -1,4 +1,4 @@
-export { withCapital } from './with-capital/with-capital';
-export { toCamelCase } from './to-camel-case/to-camel-case';
-export { toHash } from './to-hash/to-hash';
+export { withCapital } from './with-capital/with-capital';
+export { toCamelCase } from './to-camel-case/to-camel-case';
+export { toHash } from './to-hash/to-hash';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/str/to-camel-case/to-camel-case.d.ts

@@ -1,11 +1,11 @@
-/**
- * Converts a given string into camelCase format.
- * CamelCase is a convention where a multi-word identifier is formed by joining words together,
- * each starting with a capital letter except for the initial word.
- * This function takes a string as input, which may be in various formats such as snake_case,
- * kebab-case, or space-separated words, and transforms it into camelCase.
- * @param str - the input string that needs to be converted to camelCase
- * @param separators - an array of any separators, default '-', '_', ' '
- */
-export declare function toCamelCase(str: string, separators?: string[]): string;
+/**
+ * Converts a given string into camelCase format.
+ * CamelCase is a convention where a multi-word identifier is formed by joining words together,
+ * each starting with a capital letter except for the initial word.
+ * This function takes a string as input, which may be in various formats such as snake_case,
+ * kebab-case, or space-separated words, and transforms it into camelCase.
+ * @param str - the input string that needs to be converted to camelCase
+ * @param separators - an array of any separators, default '-', '_', ' '
+ */
+export declare function toCamelCase(str: string, separators?: string[]): string;
 //# sourceMappingURL=to-camel-case.d.ts.map

package/dist/types/str/to-camel-case/to-camel-case.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"to-camel-case.d.ts","sourceRoot":"","sources":["../../../../src/str/to-camel-case/to-camel-case.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,GAAE,MAAM,EAAoB,GAAG,MAAM,CAOvF"}
+{"version":3,"file":"to-camel-case.d.ts","sourceRoot":"","sources":["../../../../src/str/to-camel-case/to-camel-case.ts"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,GAAE,MAAM,EAAoB,GAAG,MAAM,CAOvF"}

package/dist/types/str/to-hash/to-hash.d.ts

@@ -1,8 +1,8 @@
-/**
- * Generates a hash value for a given input string for insecure purposes
- * Hash functions are commonly used to convert input data into a fixed-length string of characters,
- * providing a unique representation of the input
- * @param str - The input string to be hashed
- */
-export declare function toHash(str: string): string;
+/**
+ * Generates a hash value for a given input string for insecure purposes
+ * Hash functions are commonly used to convert input data into a fixed-length string of characters,
+ * providing a unique representation of the input
+ * @param str - The input string to be hashed
+ */
+export declare function toHash(str: string): string;
 //# sourceMappingURL=to-hash.d.ts.map

package/dist/types/str/to-hash/to-hash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"to-hash.d.ts","sourceRoot":"","sources":["../../../../src/str/to-hash/to-hash.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAc1C"}
+{"version":3,"file":"to-hash.d.ts","sourceRoot":"","sources":["../../../../src/str/to-hash/to-hash.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAa1C"}

package/dist/types/str/with-capital/with-capital.d.ts

@@ -1,7 +1,7 @@
-/**
- * Takes a string as input and returns a new string with the initial letter in uppercase,
- * while preserving the rest of the string
- * @param str - The input string whose first letter needs to be capitalized
- */
-export declare function withCapital(str: string): string;
+/**
+ * Takes a string as input and returns a new string with the initial letter in uppercase,
+ * while preserving the rest of the string
+ * @param str - The input string whose first letter needs to be capitalized
+ */
+export declare function withCapital(str: string): string;
 //# sourceMappingURL=with-capital.d.ts.map

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@bitfiber/utils",
   "description": "Collection of versatile utility functions for Javascript",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
-  "es2015": "./dist/esm/index.js",
+  "es2020": "./dist/esm/index.js",
   "types": "index.d.ts",
   "typesVersions": {
-    ">=4.8.2": {
+    ">=5.4.2": {
       "*": ["dist/types/*"]
     }
   },
@@ -17,49 +17,49 @@
       "types": "./dist/types/index.d.ts",
       "node": "./dist/cjs/index.js",
       "require": "./dist/cjs/index.js",
-      "es2015": "./dist/esm/index.js",
+      "es2020": "./dist/esm/index.js",
       "default": "./dist/esm/index.js"
     },
     "./arr": {
       "types": "./dist/types/arr/index.d.ts",
       "node": "./dist/cjs/arr/index.js",
       "require": "./dist/cjs/arr/index.js",
-      "es2015": "./dist/esm/arr/index.js",
+      "es2020": "./dist/esm/arr/index.js",
       "default": "./dist/esm/arr/index.js"
     },
     "./obj": {
       "types": "./dist/types/obj/index.d.ts",
       "node": "./dist/cjs/obj/index.js",
       "require": "./dist/cjs/obj/index.js",
-      "es2015": "./dist/esm/obj/index.js",
+      "es2020": "./dist/esm/obj/index.js",
       "default": "./dist/esm/obj/index.js"
     },
     "./str": {
       "types": "./dist/types/str/index.d.ts",
       "node": "./dist/cjs/str/index.js",
       "require": "./dist/cjs/str/index.js",
-      "es2015": "./dist/esm/str/index.js",
+      "es2020": "./dist/esm/str/index.js",
       "default": "./dist/esm/str/index.js"
     },
     "./num": {
       "types": "./dist/types/num/index.d.ts",
       "node": "./dist/cjs/num/index.js",
       "require": "./dist/cjs/num/index.js",
-      "es2015": "./dist/esm/num/index.js",
+      "es2020": "./dist/esm/num/index.js",
       "default": "./dist/esm/num/index.js"
     },
     "./dom": {
       "types": "./dist/types/dom/index.d.ts",
       "node": "./dist/cjs/dom/index.js",
       "require": "./dist/cjs/dom/index.js",
-      "es2015": "./dist/esm/dom/index.js",
+      "es2020": "./dist/esm/dom/index.js",
       "default": "./dist/esm/dom/index.js"
     },
     "./env": {
       "types": "./dist/types/env/index.d.ts",
       "node": "./dist/cjs/env/index.js",
       "require": "./dist/cjs/env/index.js",
-      "es2015": "./dist/esm/env/index.js",
+      "es2020": "./dist/esm/env/index.js",
       "default": "./dist/esm/env/index.js"
     },
     "./package.json": "./package.json"

package/src/arr/at/at.ts

@@ -5,6 +5,5 @@
  * @param index - item index
  */
 export function at<T>(arr: T[], index: number): T | undefined {
-  // todo: change on 'Array.at' with ES2022
-  return index < 0 ? arr[arr.length + index] : arr[index];
+  return arr.at(index);
 }

package/src/arr/diff-arr/diff-arr.ts

@@ -29,7 +29,7 @@ export interface ArrDiff<T> {
 /**
  * Returns the difference between two arrays
  * Strict comparison of array items is applied
- * The order doesn't matter
+ * The order doesn't matter, duplicate values are ignored
  * @param arr1 - array 1
  * @param arr2 - array 2
  */

package/src/common/error.ts

@@ -25,8 +25,8 @@ export class BfError extends Error {
    */
   readonly data?: any;
 
-  constructor(massage?: string, options?: BfErrorOptions) {
-    super(massage);
+  constructor(message?: string, options?: BfErrorOptions) {
+    super(message);
     this.name = 'BfError';
     this.code = options?.code;
     this.data = options?.data;

package/src/common/get-unique-str-id/get-unique-str-id.ts

@@ -12,6 +12,8 @@ const salt = random(7);
 
 /**
  * Returns a unique string identifier for the current session
+ * @note Uses Math.random for salt generation which is NOT cryptographically secure.
+ * Do not use for security-sensitive purposes such as tokens or passwords
  */
 export function getUniqueStrId(): string {
   return `${salt}${++counter}`;

package/src/common/is/is.ts

@@ -225,8 +225,8 @@ export function isTypedArray(value: any): value is TypedArr {
     case Uint8ClampedArray:
     case Uint16Array:
     case Uint32Array:
-      // case BigInt64Array:
-      // case BigUint64Array:
+    case BigInt64Array:
+    case BigUint64Array:
       return true;
     default:
       return false;

package/src/common/is-empty/is-empty.ts

@@ -4,7 +4,7 @@ import {
 import {hasOwn} from '../../obj';
 
 /**
- * Returns true if the value is empty (null, undefined, NaN, Infinity, '', {}, [], Int32Array(), Set(), Map()),
+ * Returns true if the value is empty (null, undefined, '', {}, [], Int32Array(), Set(), Map()),
  * otherwise false
  * @param value - anything
  */

package/src/common/random/random.ts

@@ -1,8 +1,11 @@
 /**
- * Returns a random integer between 0 and number, not exceeding a certain number of digits
+ * Returns a random integer between 0 and 10^numberOfDigits - 1
+ * @note Uses Math.random which is NOT cryptographically secure.
+ * Do not use for security-sensitive purposes such as tokens or passwords
  * @param numberOfDigits - number of digits (default: 7, maximum: 15)
  */
 export function random(numberOfDigits = 7): number {
-  numberOfDigits = numberOfDigits <= 15 ? numberOfDigits : 15;
-  return Math.round(Math.random() * Math.pow(10, numberOfDigits));
+  const MAX_DIGITS = 15;
+  numberOfDigits = numberOfDigits <= MAX_DIGITS ? numberOfDigits : MAX_DIGITS;
+  return Math.floor(Math.random() * Math.pow(10, numberOfDigits));
 }

package/src/dom/closest/closest.ts

@@ -5,19 +5,18 @@
  */
 export function closest(element: HTMLElement, selectors: string | HTMLElement): HTMLElement | null {
   let currentElem: HTMLElement | null = element;
+  const isElement = selectors instanceof Element;
 
   while (currentElem) {
-    if (selectors instanceof Element) {
+    if (isElement) {
       if (currentElem === selectors) {
         return currentElem;
-      } else {
-        currentElem = currentElem.parentElement;
       }
     } else if (currentElem.matches(selectors)) {
       return currentElem;
-    } else {
-      currentElem = currentElem.parentElement;
     }
+
+    currentElem = currentElem.parentElement;
   }
 
   return null;

package/src/dom/download-file/download-file.ts

@@ -14,13 +14,14 @@ export async function downloadFile(url: string, fetchOptions?: RequestInit): Pro
     const doc = getDocument();
     const win = getWindow();
     const body = getBody();
-    const url = win.URL.createObjectURL(blob);
+    const objectUrl = win.URL.createObjectURL(blob);
     const link = doc.createElement('a');
-    link.href = url;
+    link.href = objectUrl;
     link.download = 'downloaded_file';
     body.appendChild(link);
     link.click();
     body.removeChild(link);
+    win.setTimeout(() => win.URL.revokeObjectURL?.(objectUrl), 100);
     return blob;
   } else {
     return Promise.reject(new BfError(

package/src/dom/get-offset-from-parent/get-offset-from-parent.ts

@@ -44,9 +44,9 @@ export function getOffsetFromParent(element: HTMLElement): Offset {
   // Subtract the element's margin so that the element is correctly placed relative to its parent
   return {
     top: offset.top - parentOffset.top - toFloat(getStyle(element, 'marginTop')),
-    bottom: offset.bottom - parentOffset.bottom - toFloat(getStyle(element, 'marginTop')),
+    bottom: offset.bottom - parentOffset.bottom - toFloat(getStyle(element, 'marginBottom')),
     left: offset.left - parentOffset.left - toFloat(getStyle(element, 'marginLeft')),
-    right: offset.right - parentOffset.right - toFloat(getStyle(element, 'marginLeft')),
+    right: offset.right - parentOffset.right - toFloat(getStyle(element, 'marginRight')),
     width: offset.width,
     height: offset.height,
   };

package/src/dom/get-scroll-width/get-scroll-width.ts

@@ -15,15 +15,16 @@ export function getScrollWidth(element?: HTMLElement): {y: number; x: number} {
   const clientHeight2 = element.clientHeight;
 
   setStyle(element, 'overflow', originalValue);
+  const SCROLLBAR_BORDER_ADJUSTMENT = 1;
   let y = clientWidth1 - clientWidth2;
   let x = clientHeight1 - clientHeight2;
 
   if (y > 0) {
-    y += 1;
+    y += SCROLLBAR_BORDER_ADJUSTMENT;
   }
 
   if (x > 0) {
-    x += 1;
+    x += SCROLLBAR_BORDER_ADJUSTMENT;
   }
 
   return {

package/src/dom/get-style/get-style.ts

@@ -10,12 +10,12 @@ const validStyleValues: Index<[string, string]> = {
 /**
  * Returns certain computed style value of a given HTML element
  * @param element - any HTML element
- * @param styleName - any style name
+ * @param styleName - any style name in camelCase or dashed format
  */
 export function getStyle(element: HTMLElement, styleName: string): string {
-  const styles = getAllStyles(element);
+  const styles = getAllStyles(element) as unknown as Record<string, string>;
   const validName = getValidStyleName(styleName);
-  const value = styles.getPropertyValue(validName);
+  const value = styles[validName] ?? '';
 
   if (validStyleValues[validName] && value === validStyleValues[validName][0]) {
     return validStyleValues[validName][1];

package/src/dom/set-offset-from-parent/set-offset-from-parent.ts

@@ -8,8 +8,8 @@ import {TopLeft, getOffsetFromParent, setStyle, getStyle, setStyles} from '../';
  * @param offset - top and left position relative to the parent HTML element
  */
 export function setOffsetFromParent(element: HTMLElement, offset: Partial<TopLeft>): void {
-  let top = 0;
-  let left = 0;
+  let top: number;
+  let left: number;
   let styleTop = getStyle(element, 'top');
   let styleLeft = getStyle(element, 'left');
   const position = getStyle(element, 'position');
@@ -22,7 +22,7 @@ export function setOffsetFromParent(element: HTMLElement, offset: Partial<TopLef
     setStyle(element, 'position', 'relative');
   }
 
-  // If top or left is auto, need calculate real top and left relative to a non-static parent
+  // If top or left is auto, need to calculate real top and left relative to a non-static parent
   if ((position === 'absolute' || position === 'fixed')
     && (styleTop === 'auto' || styleLeft === 'auto')) {
     const offsetFromParent = getOffsetFromParent(element);

package/src/env/matches-with-browsers/matches-with-browsers.ts

@@ -9,7 +9,7 @@ import {BrowsersCondition, getEngine, isBrowser, isEngine} from '../';
  * {
  *   browserName?: versionCondition(x.x...x | [~ >= > <= <]x.x...x),
  *   engines?: engineName | {
- *     engineNane: versionCondition(x.x...x | [~ >= > <= <]x.x...x)
+ *     engineName: versionCondition(x.x...x | [~ >= > <= <]x.x...x)
  *     ...
  *   }
  *   ...

package/src/num/in-range/in-range.ts

@@ -51,7 +51,9 @@ export function inRange(value: number | Nullish, options: InRangeOptions = {}):
       newValue = options.max;
     }
   } else if (options.required) {
-    newValue = options.min || (isNumber(options.max) && options.max < 0 ? options.max : 0);
+    newValue = isNumber(options.min)
+      ? options.min
+      : (isNumber(options.max) && options.max < 0 ? options.max : 0);
   }
 
   return newValue;

package/src/obj/deep-constant/deep-constant.ts

@@ -2,17 +2,25 @@ import {isObject, Obj} from '../../common';
 import {constant} from '../';
 
 /**
- * Makes an object and its nested objects read-only
+ * Makes an object and its nested objects read-only.
+ * Objects that have been visited will be ignored to prevent looping
  * @param obj - any object
  */
 export function deepConstant<T extends Obj>(obj: T): Readonly<T> {
-  // Gets fields of enumerable and non-enumerable own properties
+  return _deepConstant(obj, new Set<Obj>());
+}
+
+function _deepConstant<T extends Obj>(obj: T, visited: Set<Obj>): Readonly<T> {
+  if (visited.has(obj)) {
+    return obj;
+  }
+  visited.add(obj);
+
   const fields = Object.getOwnPropertyNames(obj);
 
-  // Makes nested objects read-only
   fields.forEach(key => {
     if (isObject(obj[key])) {
-      deepConstant(obj[key]);
+      _deepConstant(obj[key], visited);
     }
   });
 

package/src/obj/extend/extend.ts

@@ -1,9 +1,12 @@
 import {copy, isDefined, isUsualObject, Obj, ValueIntersection} from '../../common';
 import {forEachObj} from '../';
 
+const UNSAFE_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+
 /**
  * Copies all enumerable own properties from one or more source objects to a target object.
- * It returns the modified target object
+ * It returns the modified target object.
+ * Keys __proto__, constructor and prototype are skipped to prevent prototype pollution
  * @param target - target object
  * @param sources - source objects
  */
@@ -16,8 +19,9 @@ export function extend<T extends Obj, U extends Obj[]>(
 
 /**
  * Copies all enumerable own properties from one or more source objects to a target object
- * and copies enumerable properties from nested source objects to nested target objects
- * It returns the modified target object
+ * and copies enumerable properties from nested source objects to nested target objects.
+ * It returns the modified target object.
+ * Keys __proto__, constructor and prototype are skipped to prevent prototype pollution
  * @param target - target object
  * @param sources - source objects
  */
@@ -35,6 +39,10 @@ function _extend<T extends Obj, U extends Obj[]>(target: T, sources: U, deep: bo
       visited.set(obj, true);
 
       forEachObj(obj, (value, key) => {
+        if (UNSAFE_KEYS.has(key as string)) {
+          return;
+        }
+
         const descriptor = Object.getOwnPropertyDescriptor(obj, key);
 
         if (descriptor?.get || descriptor?.set) {

package/src/obj/has-own/has-own.ts

@@ -7,6 +7,5 @@ import {Obj, NumStrSym} from '../../common';
  * @param property
  */
 export function hasOwn(obj: Obj, property: NumStrSym): boolean {
-  // todo: change on 'Object.hasOwn' with ES2022
-  return Object.prototype.hasOwnProperty.call(obj, property);
+  return Object.hasOwn(obj, property as string | symbol);
 }

package/src/str/to-camel-case/to-camel-case.ts

@@ -1,3 +1,9 @@
+const REGEX_SPECIAL_CHARS = /[.*+?^${}()|[\]\\]/g;
+
+function escapeRegExp(str: string): string {
+  return str.replace(REGEX_SPECIAL_CHARS, '\\$&');
+}
+
 /**
  * Converts a given string into camelCase format.
  * CamelCase is a convention where a multi-word identifier is formed by joining words together,
@@ -9,7 +15,7 @@
  */
 export function toCamelCase(str: string, separators: string[] = ['-', '_', ' ']): string {
   return separators.reduce((acc: string, separator: string) => {
-    const reg = new RegExp(separator + '([\\da-z])', 'gi');
+    const reg = new RegExp(escapeRegExp(separator) + '([\\da-z])', 'gi');
     return acc.replace(reg, (all: string, letter: string) => {
       return letter.toUpperCase();
     });

package/src/str/to-hash/to-hash.ts

@@ -10,8 +10,7 @@ export function toHash(str: string): string {
 
     for (let i = 0; i < str.length; i++) {
       const char = str.charCodeAt(i);
-      hash = ((hash << 5) - hash) + char;
-      hash = hash & hash;
+      hash = (((hash << 5) - hash) + char) | 0;
     }
 
     return hash < 0 ? 'hn' + Math.abs(hash) : 'hp' + hash;