@bitfiber/utils 1.0.2 → 1.0.4

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/src/common/interrupt.ts

@@ -0,0 +1,4 @@
+/**
+ * This symbol is used in forEach handlers to interrupt the loop
+ */
+export const INTERRUPT = Symbol('Symbol.INTERRUPT');

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;
+}

package/src/common/to-sorted-string/to-sorted-string.ts

@@ -0,0 +1,58 @@
+import {NumStr, isString, isDate, isRegExp, isFunction, isMap, isSet, isObject, isArray, isTypedArray} from '../';
+
+/**
+ * Converts any value to a sorted string.
+ * Sorts arrays, maps and sets by value and sorts objects by field name before adding them to a string.
+ * Objects, arrays, sets, maps etc. will be ignored if they have been visited to prevent looping
+ * @param value - anything
+ */
+export function toSortedString(value: any): string {
+  return _toSortedString(value, null, 0, new Map<any, true>());
+}
+
+function _toSortedString(value: any, index: number | null, field: NumStr, visited: Map<any, true>): string {
+  let str = index === null ? '' : ((index === 0 ? '' : ',') + (isString(field) ? field + ':' : ''));
+
+  if (isMap(value) || isSet(value)) {
+    if (visited.has(value)) {
+      return '';
+    }
+    visited.set(value, true);
+
+    value = Array.from(value);
+  }
+
+  if (isArray(value) || isTypedArray(value)) {
+    if (visited.has(value)) {
+      return '';
+    }
+    visited.set(value, true);
+
+    str += '[';
+    value.sort();
+    value.forEach((value: any, i: number) => {
+      str += _toSortedString(value, i, i, visited);
+    });
+    str += ']';
+  } else if (isFunction(value)) {
+    str += value.toString();
+  } else if (isObject(value) && !isDate(value) && !isRegExp(value)) {
+    if (visited.has(value)) {
+      return '';
+    }
+    visited.set(value, true);
+
+    const fields = Object.keys(value);
+
+    str += '{';
+    fields.sort();
+    fields.forEach((field, i) => {
+      str += _toSortedString(value[field], i, field, visited);
+    });
+    str += '}';
+  } else {
+    str += value;
+  }
+
+  return str;
+}