@bitfiber/utils 1.0.1 → 1.0.3

package/src/common/copy/copy.ts

@@ -0,0 +1,89 @@
+import {
+  isNumber, isBigInt, isBoolean, isString, isDate, isRegExp, isFunction, isMap, isSet, isObject, isArray, isTypedArray,
+  isBlob, isArrayBuffer, isWindow, isDocument, isFile, isFormData, isPromise, isObservable,
+} from '../';
+import {forEachObj} from '../../obj';
+
+/**
+ * Creates a deep copy of a value of any type
+ * Objects, arrays, sets, maps etc. will be ignored if they have been visited to prevent looping
+ * @param value - anything
+ */
+export function copy<T>(value: T): T {
+  return _copy(value, new Map());
+}
+
+function _copy(value: any, visited: Map<any, any>): any {
+  if (!value || isString(value) || isNumber(value) || isBigInt(value) || isBoolean(value) || isFunction(value)) {
+    return value;
+  } else if (isDate(value)) {
+    return new Date(value.getTime());
+  } else if (isArray(value)) {
+    if (visited.has(value)) {
+      return visited.get(value);
+    }
+
+    const arr: any[] = [];
+    visited.set(value, arr);
+    value.forEach(item => arr.push(_copy(item, visited)));
+
+    return arr;
+  } else if (isSet(value)) {
+    if (visited.has(value)) {
+      return visited.get(value);
+    }
+
+    const newSet = new Set();
+    visited.set(value, newSet);
+    value.forEach(item => newSet.add(_copy(item, visited)));
+
+    return newSet;
+  } else if (isMap(value)) {
+    if (visited.has(value)) {
+      return visited.get(value);
+    }
+
+    const newMap = new Map();
+    visited.set(value, newMap);
+
+    value.forEach((item, key) => newMap.set(_copy(key, visited), _copy(item, visited)));
+
+    return newMap;
+  } else if (isRegExp(value)) {
+    // @ts-ignore
+    const reg = new RegExp(value.source, value.toString().match(/[^/]*$/)[0]);
+    reg.lastIndex = value.lastIndex;
+    return reg;
+  } else if (isBlob(value)) {
+    return new Blob([value], {type: value.type});
+  } else if (isArrayBuffer(value)) {
+    return value.slice(0);
+  } else if (isTypedArray(value)) {
+    // @ts-ignore
+    return new value.constructor(value.buffer.slice(0), value.byteOffset, value.length);
+  } else if (isWindow(value) || isDocument(value) || isFile(value) || isFormData(value) || isPromise(value)
+    || isObservable(value)) {
+    return value;
+  } else if (isObject(value)) {
+    if (visited.has(value)) {
+      return visited.get(value);
+    }
+
+    const obj = Object.create(Object.getPrototypeOf(value));
+    visited.set(value, obj);
+
+    forEachObj(value, (val, key) => {
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+
+      if (descriptor?.get || descriptor?.set) {
+        Object.defineProperty(obj, key, descriptor);
+      } else {
+        obj[key] = _copy(val, visited);
+      }
+    });
+
+    return obj;
+  } else {
+    return value;
+  }
+}

package/src/common/equals/equals.ts

@@ -0,0 +1,142 @@
+import {
+  Index, isNaN, isDate, isRegExp, isFunction, isDefined, isMap, isSet, isObject, isArray, isTypedArray,
+} from '../';
+import {hasOwn} from '../../obj';
+
+/**
+ * Determines whether two values are equal.
+ * The comparison is performed to the full depth of nesting.
+ * Objects are equal if they have the same fields with equal values.
+ * Arrays and sets are equal if they have the same length and equal values in the same order.
+ * Maps are equal if they have the same keys with equal values.
+ * Objects, arrays, sets, maps etc. will be ignored if they have been visited to prevent looping
+ * @param value1 - anything
+ * @param value2 - anything
+ * @param sortFn - if added, arrays and sets will be sorted before comparison
+ */
+export function equals(value1: any, value2: any, sortFn?: (a: any, b: any) => number): boolean {
+  return _equals(value1, value2, new Map<any, true>(), sortFn);
+}
+
+function _equals(obj1: any, obj2: any, visited: Map<any, true>, sortFn?: (a: any, b: any) => number): boolean {
+  if (obj1 === obj2 || (isNaN(obj1) && isNaN(obj2))) {
+    return true;
+  } else if (isArray(obj1) || isTypedArray(obj1)) {
+    if (visited.has(obj1)) {
+      return true;
+    }
+    visited.set(obj1, true);
+
+    if ((!isArray(obj2) && !isTypedArray(obj2)) || obj1.length !== obj2.length) {
+      return false;
+    }
+
+    let arr1 = obj1;
+    let arr2 = obj2;
+
+    if (sortFn) {
+      arr1 = [...obj1].sort(sortFn);
+      arr2 = [...obj2].sort(sortFn);
+    }
+
+    for (let i = 0; i < arr1.length; i++) {
+      if (!_equals(arr1[i], arr2[i], visited, sortFn)) {
+        return false;
+      }
+    }
+
+    return true;
+  } else if (isFunction(obj1)) {
+    return false;
+  } else if (isDate(obj1)) {
+    return isDate(obj2) && obj1.getTime() === obj2.getTime();
+  } else if (isRegExp(obj1)) {
+    return isRegExp(obj2) && obj1.toString() === obj2.toString();
+  } else if (isMap(obj1)) {
+    if (visited.has(obj1)) {
+      return true;
+    }
+    visited.set(obj1, true);
+
+    if (!isMap(obj2) || obj1.size !== obj2.size) {
+      return false;
+    }
+
+    const map = new Map<any, true>();
+
+    for (const [key, value] of obj1) {
+      if (!_equals(value, obj2.get(key), visited, sortFn)) {
+        return false;
+      }
+
+      map.set(key, true);
+    }
+
+    for (const [key, value] of obj2) {
+      if (!map.has(key) && isDefined(value)) {
+        return false;
+      }
+    }
+
+    return true;
+  } else if (isSet(obj1)) {
+    if (visited.has(obj1)) {
+      return true;
+    }
+    visited.set(obj1, true);
+
+    if (!isSet(obj2) || obj1.size !== obj2.size) {
+      return false;
+    }
+
+    const arr1 = Array.from(obj1);
+    const arr2 = Array.from(obj2);
+
+    if (sortFn) {
+      arr1.sort(sortFn);
+      arr2.sort(sortFn);
+    }
+
+    for (let i = 0; i < arr1.length; i++) {
+      if (!_equals(arr1[i], arr2[i], visited, sortFn)) {
+        return false;
+      }
+    }
+
+    return true;
+  } else if (isObject(obj1)) {
+    if (visited.has(obj1)) {
+      return true;
+    }
+    visited.set(obj1, true);
+
+    if (!isObject(obj2) || isArray(obj2) || isTypedArray(obj2) || isDate(obj2) || isRegExp(obj2) || isMap(obj2)
+      || isSet(obj2)) {
+      return false;
+    }
+
+    const obj: Index<true> = {};
+
+    for (const key in obj1) {
+      if (!hasOwn(obj1, key) || isFunction(obj1[key])) {
+        continue;
+      } else if (!_equals(obj1[key], obj2[key], visited, sortFn)) {
+        return false;
+      }
+
+      obj[key] = true;
+    }
+
+    for (const key in obj2) {
+      if (!hasOwn(obj2, key) || isFunction(obj2[key])) {
+        continue;
+      } else if (!hasOwn(obj, key) && isDefined(obj2[key])) {
+        return false;
+      }
+    }
+
+    return true;
+  } else {
+    return false;
+  }
+}

package/src/common/error.ts

@@ -0,0 +1,34 @@
+/**
+ * Represents additional error options the BfError class
+ */
+export interface BfErrorOptions {
+  code?: string;
+  data?: any;
+}
+
+/**
+ * Extends the Error class and adds additional parameters: date, code, data
+ */
+export class BfError extends Error {
+  /**
+   * Creation date
+   */
+  readonly date = new Date();
+
+  /**
+   * Unique error code
+   */
+  readonly code?: string;
+
+  /**
+   * Any additional data for error handling
+   */
+  readonly data?: any;
+
+  constructor(massage?: string, options?: BfErrorOptions) {
+    super(massage);
+    this.name = 'BfError';
+    this.code = options?.code;
+    this.data = options?.data;
+  }
+}

package/src/common/for-each/for-each.ts

@@ -0,0 +1,36 @@
+import {NumStr, BfError, INTERRUPT, isNumber, isFunction, isMap, isSet, isObject, hasIterator} from '../';
+import {forEachArr} from '../../arr';
+import {forEachObj} from '../../obj';
+
+/**
+ * Iterates through all the items of any iterable object and calls a handler for each item
+ * If the handler returns INTERRUPT, the loop will be interrupted
+ * @param obj - any iterable object
+ * @param handler - function called for each item
+ * @param reverse - iterates in reverse order if true
+ */
+export function forEach(obj: any, handler: (value: any, key: NumStr, obj: any) => any, reverse?: boolean): void {
+  if (hasIterator(obj)) {
+    if (isMap(obj)) {
+      const iterable = Array.from(obj);
+      forEachArr(iterable, entry => handler(entry[1], entry[0], obj), reverse);
+    } else if (isFunction(obj.forEach) || isNumber(obj.length)) {
+      const iterable: any = isSet(obj) ? Array.from(obj) : obj;
+      forEachArr(iterable, (value, i) => handler(value, i, obj), reverse);
+    } else {
+      let i = 0;
+      for (const item of obj) {
+        if (handler(item, i++, obj) === INTERRUPT) {
+          return;
+        }
+      }
+    }
+  } else if (isObject(obj)) {
+    forEachObj(obj, handler);
+  } else {
+    throw new BfError('Invalid iterable object', {
+      code: 'bf_utils_forEach_1',
+      data: obj,
+    });
+  }
+}

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

@@ -0,0 +1,8 @@
+import {getUniqueStrId} from '../';
+
+/**
+ * Returns a unique number identifier for the current session
+ */
+export function getUniqueNumId(): number {
+  return Number(getUniqueStrId());
+}

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

@@ -0,0 +1,18 @@
+import {random} from '../random/random';
+
+/*
+ * Counter for the getUniqueStrId function
+ */
+let counter = 0;
+
+/*
+ * Salt for the getUniqueStrId function
+ */
+const salt = random(7);
+
+/**
+ * Returns a unique string identifier for the current session
+ */
+export function getUniqueStrId(): string {
+  return `${salt}${++counter}`;
+}

package/src/common/has-iterator/has-iterator.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns true if the value has an iterator, otherwise false
+ * @param value - anything
+ */
+export function hasIterator(value: any): boolean {
+  return !!(value && value[Symbol.iterator]);
+}

package/src/common/index.ts

@@ -0,0 +1,23 @@
+export {
+  Nullish, NumStr, NumStrSym, Fn, Arr, TypedArr, Obj, Index, ArrObj, UnionToIntersection, ValueUnion, ValueIntersection,
+} from './types';
+export {INTERRUPT} from './interrupt';
+export {BfError, BfErrorOptions} from './error';
+export {stub} from './stub/stub';
+export {
+  isNull, isUndefined, isDefined, isNullish, isNaN, isString, isNumber, isBigInt, isBoolean, isSymbol, isFunction,
+  isObject, isArray, isSet, isMap, isDate, isRegExp, isFile, isBlob, isFormData, isArrayBuffer, isDocument, isWindow,
+  isPromise, isObservable, isTypedArray, isUsualObject,
+} from './is/is';
+export {isEmpty} from './is-empty/is-empty';
+export {same} from './same/same';
+export {random} from './random/random';
+export {toInt} from './to-int/to-int';
+export {toFloat} from './to-float/to-float';
+export {hasIterator} from './has-iterator/has-iterator';
+export {getUniqueStrId} from './get-unique-str-id/get-unique-str-id';
+export {getUniqueNumId} from './get-unique-num-id/get-unique-num-id';
+export {toSortedString} from './to-sorted-string/to-sorted-string';
+export {forEach} from './for-each/for-each';
+export {equals} from './equals/equals';
+export {copy} from './copy/copy';

package/{common/types.js → src/common/interrupt.ts}

@@ -2,4 +2,3 @@
  * This symbol is used in forEach handlers to interrupt the loop
  */
 export const INTERRUPT = Symbol('Symbol.INTERRUPT');
-//# sourceMappingURL=types.js.map

package/src/common/is/is.ts

@@ -0,0 +1,244 @@
+import {Fn, TypedArr, Obj, Nullish} from '../';
+
+/*
+ * Why is typeof or constructor used to check type?
+ * For 100 000 000 iterations type checking is spending:
+ * by typeof: ~75 milliseconds
+ * by constructor: ~75 milliseconds
+ * by instanceof: ~255 milliseconds
+ * by toString.call: ~850 milliseconds
+ */
+
+/**
+ * Returns true if the value is null, otherwise false
+ * @param value - anything
+ */
+export function isNull(value: any): value is null {
+  return value === null;
+}
+
+/**
+ * Returns true if the value is undefined, otherwise false
+ * @param value - anything
+ */
+export function isUndefined(value: any): value is undefined {
+  return typeof value === 'undefined';
+}
+
+/**
+ * Returns true if the value is defined, otherwise false
+ * @param value - anything
+ */
+export function isDefined(value: any): boolean {
+  return typeof value !== 'undefined';
+}
+
+/**
+ * Returns true if the value is undefined or null, otherwise false
+ * @param value - anything
+ */
+export function isNullish(value: any): value is Nullish {
+  return isNull(value) || isUndefined(value);
+}
+
+/**
+ * Returns true if the value is NaN, otherwise false
+ * @param value - anything
+ */
+export function isNaN(value: any): value is typeof NaN {
+  return Number.isNaN(value);
+}
+
+/**
+ * Returns true if the value is a string, otherwise false
+ * @param value - anything
+ */
+export function isString(value: any): value is string {
+  return typeof value === 'string';
+}
+
+/**
+ * Returns true if the value is a number, otherwise false
+ * @param value - anything
+ */
+export function isNumber(value: any): value is number {
+  return typeof value === 'number';
+}
+
+/**
+ * Returns true if the value is a big integer, otherwise false
+ * @param value - anything
+ */
+export function isBigInt(value: any): value is bigint {
+  return typeof value === 'bigint';
+}
+
+/**
+ * Returns true if the value is a boolean, otherwise false
+ * @param value - anything
+ */
+export function isBoolean(value: any): value is boolean {
+  return typeof value === 'boolean';
+}
+
+/**
+ * Returns true if the value is a symbol, otherwise false
+ * @param value - anything
+ */
+export function isSymbol(value: any): value is symbol {
+  return typeof value === 'symbol';
+}
+
+/**
+ * Returns true if the value is a function, otherwise false
+ * @param value - anything
+ */
+export function isFunction(value: any): value is Fn {
+  return typeof value === 'function';
+}
+
+/**
+ * Returns true if the value is an object, otherwise false
+ * @param value - anything
+ */
+export function isObject(value: any): value is Obj {
+  return !!value && typeof value === 'object';
+}
+
+/**
+ * Returns true if the value is an array, otherwise false
+ * @param value - anything
+ */
+export function isArray(value: any): value is Array<any> {
+  return Array.isArray(value);
+}
+
+/**
+ * Returns true if the value is a set, otherwise false
+ * @param value - anything
+ */
+export function isSet(value: any): value is Set<any> {
+  return !!value && value.constructor === Set;
+}
+
+/**
+ * Returns true if the value is a map, otherwise false
+ * @param value - anything
+ */
+export function isMap(value: any): value is Map<any, any> {
+  return !!value && value.constructor === Map;
+}
+
+/**
+ * Returns true if the value is a date, otherwise false
+ * @param value - anything
+ */
+export function isDate(value: any): value is Date {
+  return !!value && value.constructor === Date;
+}
+
+/**
+ * Returns true if the value is a regular expression, otherwise false
+ * @param value - anything
+ */
+export function isRegExp(value: any): value is RegExp {
+  return !!value && value.constructor === RegExp;
+}
+
+/**
+ * Returns true if the value is a file, otherwise false
+ * @param value - anything
+ */
+export function isFile(value: any): value is File {
+  return !!value && value.constructor === File;
+}
+
+/**
+ * Returns true if the value is a blob, otherwise false
+ * @param value - anything
+ */
+export function isBlob(value: any): value is Blob {
+  return !!value && value.constructor === Blob;
+}
+
+/**
+ * Returns true if the value is form data, otherwise false
+ * @param value - anything
+ */
+export function isFormData(value: any): value is FormData {
+  return !!value && value.constructor === FormData;
+}
+
+/**
+ * Returns true if the value is an array buffer, otherwise false
+ * @param value - anything
+ */
+export function isArrayBuffer(value: any): value is ArrayBuffer {
+  return !!value && value.constructor === ArrayBuffer;
+}
+
+/**
+ * Returns true if the value is a document, otherwise false
+ * @param value - anything
+ */
+export function isDocument(value: any): value is Document {
+  return !!value && typeof Document === 'function' && value.constructor === Document;
+}
+
+/**
+ * Returns true if the value is a window, otherwise false
+ * @param value - anything
+ */
+export function isWindow(value: any): value is Window {
+  return !!value && value.window === value;
+}
+
+/**
+ * Returns true if the value is a promise, otherwise false
+ * @param value - anything
+ */
+export function isPromise(value: any): value is Promise<any> {
+  return !!value && (value.constructor === Promise || (isFunction(value.then) && isFunction(value.catch)));
+}
+
+/**
+ * Returns true if the value is an observable, otherwise false
+ * @param value - anything
+ */
+export function isObservable(value: any): boolean {
+  return !!value && isFunction(value.pipe) && isFunction(value.subscribe);
+}
+
+/**
+ * Returns true if the value is a typed array, otherwise false
+ * @param value - anything
+ */
+export function isTypedArray(value: any): value is TypedArr {
+  switch (value?.constructor) {
+    case Int8Array:
+    case Int16Array:
+    case Int32Array:
+    case Float32Array:
+    case Float64Array:
+    case Uint8Array:
+    case Uint8ClampedArray:
+    case Uint16Array:
+    case Uint32Array:
+      // case BigInt64Array:
+      // case BigUint64Array:
+      return true;
+    default:
+      return false;
+  }
+}
+
+/**
+ * Returns true if the value is a usual object, otherwise false
+ * @param value - anything
+ */
+export function isUsualObject(value: any): value is Obj {
+  return isObject(value) && !isArray(value) && !isTypedArray(value) && !isSet(value) && !isMap(value) && !isDate(value)
+    && !isRegExp(value) && !isFile(value) && !isBlob(value) && !isFormData(value) && !isArrayBuffer(value) && !isWindow(
+    value,
+  ) && !isDocument(value) && !isPromise(value) && !isObservable(value);
+}

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

@@ -0,0 +1,26 @@
+import {isNumber, isBigInt, isBoolean, isSymbol, isString, isDate, isRegExp, isFunction, isDefined} from '../';
+import {hasOwn} from '../../obj';
+
+/**
+ * Returns true if the value is empty (null, undefined, NaN, Infinity, '', {}, [], Int32Array(), Set(), Map()),
+ * otherwise false
+ * @param value - anything
+ */
+export function isEmpty(value: any): boolean {
+  if (isNumber(value) || isBigInt(value) || isBoolean(value) || isSymbol(value)) {
+    return false;
+  } else if (!value) {
+    return true;
+  } else if (isString(value) || isDate(value) || isRegExp(value) || isFunction(value)) {
+    return false;
+  } else if (isFunction(value.forEach)) {
+    return value.length === 0 || value.size === 0;
+  } else {
+    for (const key in value) {
+      if (hasOwn(value, key) && isDefined(value[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+}

package/src/common/random/random.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns a random integer between 0 and number, not exceeding a certain number of digits
+ * @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));
+}

package/src/common/same/same.ts

@@ -0,0 +1,8 @@
+/**
+ * Determines whether two values are the same value
+ * @param value1 - anything
+ * @param value2 - anything
+ */
+export function same(value1: any, value2: any): boolean {
+  return (value1 === 0 && value2 === 0) || Object.is(value1, value2);
+}

package/src/common/stub/stub.ts

@@ -0,0 +1,7 @@
+/**
+ * Can replace any required function,
+ * takes any arguments and returns anything
+ */// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function stub(...args: any[]): any {
+  return;
+}

package/src/common/to-float/to-float.ts

@@ -0,0 +1,10 @@
+import {NumStr, isNumber} from '../';
+
+/**
+ * Converts a string to a float and replaces NaN and Infinity with 0
+ * @param value - a string or number
+ */
+export function toFloat(value: NumStr): number {
+  const num = isNumber(value) ? value : parseFloat(value);
+  return isFinite(num) ? num : 0;
+}

package/src/common/to-int/to-int.ts

@@ -0,0 +1,10 @@
+import {NumStr, isNumber} from '../';
+
+/**
+ * Converts a string to an integer and replaces NaN and Infinity with 0
+ * @param value - a string or number
+ */
+export function toInt(value: NumStr): number {
+  const num = isNumber(value) ? value : parseInt(value, 10);
+  return isFinite(num) ? num : 0;
+}