@bitfiber/utils 1.0.2 → 1.0.4

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from './common/index';
+export * from './num/index';
+export * from './str/index';
+export * from './obj/index';
+export * from './arr/index';
+export * from './dom/index';
+export * from './env/index';

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

@@ -0,0 +1,54 @@
+import {isNumber, Nullish} from '../../common';
+import {round} from '../';
+
+/**
+ * Represents options type for the inRange function
+ */
+export interface InRangeOptions {
+
+  /**
+   * If the minimum is specified and the value is less than the minimum,
+   * the value will be replaced with the minimum
+   */
+  min?: number;
+
+  /**
+   * If the maximum is specified and the value is greater than the maximum,
+   * the value will be replaced with the maximum
+   */
+  max?: number;
+
+  /**
+   * If the precision is specified, the value will be rounded to the number of decimal places
+   */
+  precision?: number;
+
+  /**
+   * If true, the empty value will be replaced with
+   * either the defined minimum or defined maximum if the maximum is less than 0 or 0
+   */
+  required?: boolean;
+}
+
+/**
+ * Converts the numeric value to a new number according to the options
+ * @param value - numeric value
+ * @param options - options for converting the numeric value
+ */
+export function inRange(value: number | Nullish, options: InRangeOptions = {}): number | null {
+  let newValue = isNumber(value) ? (isNumber(options.precision) ? round(value, options.precision) : value) : null;
+
+  if (isNumber(newValue)) {
+    if (isNumber(options.min) && newValue < options.min) {
+      newValue = options.min;
+    }
+
+    if (isNumber(options.max) && newValue > options.max) {
+      newValue = options.max;
+    }
+  } else if (options.required) {
+    newValue = options.min || (isNumber(options.max) && options.max < 0 ? options.max : 0);
+  }
+
+  return newValue;
+}

package/src/num/index.ts

@@ -0,0 +1,2 @@
+export {round} from './round/round';
+export {inRange, InRangeOptions} from './in-range/in-range';

package/src/num/round/round.ts

@@ -0,0 +1,10 @@
+/**
+ * Rounds a numeric value to a number with a specified number of decimal places
+ * and replaces NaN and Infinity with 0
+ * @param value - numeric value
+ * @param precision - number of decimal places, default 0
+ */
+export function round(value: number, precision = 0): number {
+  const num = Number(value.toFixed(precision));
+  return isFinite(num) ? num : 0;
+}

package/src/obj/constant/constant.ts

@@ -0,0 +1,9 @@
+import {Obj} from '../../common';
+
+/**
+ * Makes an object read-only
+ * @param obj - any object
+ */
+export function constant<T extends Obj>(obj: T): Readonly<T> {
+  return Object.freeze(obj);
+}

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

@@ -0,0 +1,20 @@
+import {isObject, Obj} from '../../common';
+import {constant} from '../';
+
+/**
+ * Makes an object and its nested objects read-only
+ * @param obj - any object
+ */
+export function deepConstant<T extends Obj>(obj: T): Readonly<T> {
+  // Gets fields of enumerable and non-enumerable own properties
+  const fields = Object.getOwnPropertyNames(obj);
+
+  // Makes nested objects read-only
+  fields.forEach(key => {
+    if (isObject(obj[key])) {
+      deepConstant(obj[key]);
+    }
+  });
+
+  return constant(obj);
+}

package/src/obj/diff-obj/diff-obj.ts

@@ -0,0 +1,87 @@
+import {equals, isDefined, isUndefined, Obj} from '../../common';
+import {forEachObj} from '../';
+
+/**
+ * Represents response of the diffObj function
+ */
+export interface ObjDiff<T extends Obj> {
+
+  /**
+   * Contains equal fields for object 1 and object 2
+   */
+  equal: Partial<T>;
+
+  /**
+   * Contains fields that are only in object 1 or are not equal to the fields of object 2
+   */
+  notEqual1: Partial<T>;
+
+  /**
+   * Contains fields that are only in object 2 or are not equal to the fields of object 1
+   */
+  notEqual2: Partial<T>;
+
+  /**
+   * Contains fields that are only in object 1
+   */
+  only1: Partial<T>;
+
+  /**
+   * Contains fields that are only in object 2
+   */
+  only2: Partial<T>;
+
+  /**
+   * True if notEqual1 and notEqual2 are empty, otherwise false
+   */
+  isEqual: boolean;
+}
+
+/**
+ * Returns the difference between two objects
+ * @param obj1 - any object 1
+ * @param obj2 - any object 2
+ * @param sortFn - if added, arrays and sets will be sorted before comparison
+ */
+export function diffObj<T1 extends Obj, T2 extends Obj>(obj1: T1, obj2: T2,
+  sortFn?: (a: any, b: any) => number): ObjDiff<T1 & T2> {
+  let isEqual = true;
+  const equal: Partial<T1 & T2> = {};
+  const notEqual1: Partial<T1 & T2> = {};
+  const notEqual2: Partial<T1 & T2> = {};
+  const only1: Partial<T1 & T2> = {};
+  const only2: Partial<T1 & T2> = {};
+
+  forEachObj(obj1, (value, key) => {
+    if (isDefined(value)) {
+      if (equals(value, obj2[key], sortFn)) {
+        equal[key] = value;
+      } else {
+        isEqual = false;
+        notEqual1[key] = value;
+
+        if (isDefined(obj2[key])) {
+          notEqual2[key] = obj2[key];
+        } else {
+          only1[key] = notEqual1[key];
+        }
+      }
+    }
+  });
+
+  forEachObj(obj2, (value, key) => {
+    if (isDefined(value) && isUndefined(equal[key]) && isUndefined(notEqual1[key])) {
+      isEqual = false;
+      notEqual2[key] = only2[key] = value;
+    }
+  });
+
+  return {
+    equal,
+    notEqual1,
+    notEqual2,
+    only1,
+    only2,
+    isEqual,
+  };
+}

package/src/obj/exclude/exclude.ts

@@ -0,0 +1,18 @@
+import {isDefined, Obj} from '../../common';
+import {forEachObj} from '../';
+
+/**
+ * Returns a new object with the fields of the passed object, excluding the specified set of fields
+ * @param obj - any object
+ * @param fields - set of fields to be excluded
+ */
+export function exclude<T extends Obj, K extends keyof T>(obj: T, ...fields: K[]): Omit<T, K> {
+  const result = <Omit<T, K>>{};
+  forEachObj(obj, (value, key) => {
+    if (isDefined(value) && !fields.includes(<K>key)) {
+      // @ts-ignore
+      result[key] = value;
+    }
+  });
+  return result;
+}

package/src/obj/extend/extend.ts

@@ -0,0 +1,54 @@
+import {copy, isDefined, isUsualObject, Obj, ValueIntersection} from '../../common';
+import {forEachObj} from '../';
+
+/**
+ * Copies all enumerable own properties from one or more source objects to a target object.
+ * It returns the modified target object
+ * @param target - target object
+ * @param sources - source objects
+ */
+export function extend<T extends Obj, U extends Obj[]>(target: T,
+  ...sources: U): T & ValueIntersection<typeof sources> {
+  return _extend(target, sources, false, new Map<any, true>());
+}
+
+/**
+ * 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
+ * @param target - target object
+ * @param sources - source objects
+ */
+export function extendAll<T extends Obj, U extends Obj[]>(target: T,
+  ...sources: U): T & ValueIntersection<typeof sources> {
+  return _extend(target, sources, true, new Map<any, true>());
+}
+
+function _extend<T extends Obj, U extends Obj[]>(target: T, sources: U, deep: boolean,
+  visited: Map<any, true>): T & ValueIntersection<typeof sources> {
+  sources.forEach(obj => {
+    if (obj !== target && !visited.has(obj) && isUsualObject(obj)) {
+      visited.set(obj, true);
+
+      forEachObj(obj, (value, key) => {
+        const descriptor = Object.getOwnPropertyDescriptor(obj, key);
+
+        if (descriptor?.get || descriptor?.set) {
+          Object.defineProperty(target, key, descriptor);
+        } else if (isDefined(value)) {
+          if (deep) {
+            if (isUsualObject(target[key]) && isUsualObject(obj[key])) {
+              (<any>target)[key] = _extend(target[key], [obj[key]], true, visited);
+            } else {
+              (<any>target)[key] = copy(obj[key]);
+            }
+          } else {
+            (<any>target)[key] = obj[key];
+          }
+        }
+      });
+    }
+  });
+
+  return <T & ValueIntersection<typeof sources>>target;
+}

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

@@ -0,0 +1,17 @@
+import {Obj, INTERRUPT, ValueUnion} from '../../common';
+import {hasOwn} from '../';
+
+/**
+ * Iterates through all the fields of an object and calls a handler for each field
+ * If the handler returns INTERRUPT, the loop will be interrupted
+ * @param obj - any object
+ * @param handler - function called for each field
+ */
+export function forEachObj<T extends Obj, K extends keyof T>(obj: T,
+  handler: (value: ValueUnion<T>, key: K, obj: T) => any): void {
+  for (const key in obj) {
+    if (hasOwn(obj, key) && handler(obj[key], <Extract<K, string>>key, obj) === INTERRUPT) {
+      return;
+    }
+  }
+}

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

@@ -0,0 +1,12 @@
+import {Obj, NumStrSym} from '../../common';
+
+/**
+ * Returns true if the object has the indicated property as its own property.
+ * If the property is inherited, or does not exist, the method returns false
+ * @param obj - any object
+ * @param property
+ */
+export function hasOwn(obj: Obj, property: NumStrSym): boolean {
+  // todo: change on 'Object.hasOwn' with ES2022
+  return Object.prototype.hasOwnProperty.call(obj, property);
+}

package/src/obj/include/include.ts

@@ -0,0 +1,17 @@
+import {isDefined, Obj} from '../../common';
+import {hasOwn} from '../';
+
+/**
+ * Returns a new object with the specified set of fields
+ * @param obj - any object
+ * @param fields - set of fields to be included
+ */
+export function include<T extends Obj, K extends keyof T>(obj: T, ...fields: K[]): Pick<T, K> {
+  const result = <Pick<T, K>>{};
+  fields.forEach(key => {
+    if (hasOwn(obj, key) && isDefined(obj[key])) {
+      result[key] = obj[key];
+    }
+  });
+  return result;
+}

package/src/obj/index.ts

@@ -0,0 +1,12 @@
+export {hasOwn} from './has-own/has-own';
+export {forEachObj} from './for-each-obj/for-each-obj';
+export {keys} from './keys/keys';
+export {values} from './values/values';
+export {include} from './include/include';
+export {exclude} from './exclude/exclude';
+export {constant} from './constant/constant';
+export {deepConstant} from './deep-constant/deep-constant';
+export {mapObj} from './map-obj/map-obj';
+export {mapObjToArr} from './map-obj-to-arr/map-obj-to-arr';
+export {diffObj, ObjDiff} from './diff-obj/diff-obj';
+export {extend, extendAll} from './extend/extend';

package/src/obj/keys/keys.ts

@@ -0,0 +1,9 @@
+import {Obj} from '../../common';
+
+/**
+ * Returns an array of the object's own enumerable property names
+ * @param obj - any object
+ */
+export function keys<T extends Obj>(obj: T): (keyof T)[] {
+  return Object.keys(obj);
+}

package/src/obj/map-obj/map-obj.ts

@@ -0,0 +1,14 @@
+import {Obj, ValueUnion} from '../../common';
+import {forEachObj} from '../';
+
+/**
+ * Returns a new object, which has the mapped values of object fields
+ * @param obj - any object
+ * @param handler - function called for each field
+ */
+export function mapObj<T extends Obj, K extends keyof T, R>(obj: T,
+  handler: (value: ValueUnion<T>, key: K, obj: T) => R): Record<K, R> {
+  const result = <Record<K, R>>{};
+  forEachObj(obj, (value, key) => result[<K>key] = handler(value, <K>key, obj));
+  return result;
+}

package/src/obj/map-obj-to-arr/map-obj-to-arr.ts

@@ -0,0 +1,14 @@
+import {Obj, ValueUnion} from '../../common';
+import {forEachObj} from '../';
+
+/**
+ * Returns an array, which has the mapped values of object fields
+ * @param obj - any object
+ * @param handler - function called for each field
+ */
+export function mapObjToArr<T extends Obj, K extends keyof T, R>(obj: T,
+  handler: (value: ValueUnion<T>, key: K, obj: T) => R): R[] {
+  const result: R[] = [];
+  forEachObj(obj, (value, key) => result.push(handler(value, <K>key, obj)));
+  return result;
+}

package/src/obj/values/values.ts

@@ -0,0 +1,12 @@
+import {Obj} from '../../common';
+import {forEachObj} from '../';
+
+/**
+ * Returns an array of values for each object's own enumerable property
+ * @param obj - any object
+ */
+export function values<T>(obj: Obj<T>): T[] {
+  const result: T[] = [];
+  forEachObj(obj, value => result.push(value));
+  return result;
+}

package/src/str/index.ts

@@ -0,0 +1,3 @@
+export {withCapital} from './with-capital/with-capital';
+export {toCamelCase} from './to-camel-case/to-camel-case';
+export {toHash} from './to-hash/to-hash';

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

@@ -0,0 +1,17 @@
+/**
+ * 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 function toCamelCase(str: string, separators: string[] = ['-', '_', ' ']): string {
+  return separators.reduce((acc: string, separator: string) => {
+    const reg = new RegExp(separator + '([\\da-z])', 'gi');
+    return acc.replace(reg, (all: string, letter: string) => {
+      return letter.toUpperCase();
+    });
+  }, str);
+}

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

@@ -0,0 +1,21 @@
+/**
+ * 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 function toHash(str: string): string {
+  if (str) {
+    let hash = 0;
+
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = ((hash << 5) - hash) + char;
+      hash = hash & hash;
+    }
+
+    return hash < 0 ? 'hn' + Math.abs(hash) : 'hp' + hash;
+  } else {
+    return '';
+  }
+}

package/src/str/with-capital/with-capital.ts

@@ -0,0 +1,8 @@
+/**
+ * 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 function withCapital(str: string): string {
+  return str.charAt(0).toUpperCase() + str.substring(1);
+}

package/arr/at/at.d.ts

@@ -1,7 +0,0 @@
-/**
- * Returns the array item at index, or undefined if there is no index.
- * For negative indexes, returns items from the end
- * @param arr - any array
- * @param index - item index
- */
-export declare function at<T>(arr: T[], index: number): T | undefined;

package/arr/at/at.js

@@ -1,11 +0,0 @@
-/**
- * Returns the array item at index, or undefined if there is no index.
- * For negative indexes, returns items from the end
- * @param arr - any array
- * @param index - item index
- */
-export function at(arr, index) {
-    // todo: change on 'Array.at' with ES2022
-    return index < 0 ? arr[arr.length + index] : arr[index];
-}
-//# sourceMappingURL=at.js.map

package/arr/at/at.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"at.js","sourceRoot":"","sources":["../../../../package/src/arr/at/at.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,UAAU,EAAE,CAAI,GAAQ,EAAE,KAAa;IAC3C,yCAAyC;IACzC,OAAO,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;AAC1D,CAAC"}

package/arr/cnd/cnd.d.ts

@@ -1,55 +0,0 @@
-import { MatchConditionFn, MatchConditions } from '../';
-/**
- * Returns a function that checks if a value matches the conditions
- * @example
- * import {cnd} from '@bitfiber/utils/arr';
- *
- * const obj1 = {name: 'Alex'};
- * const obj2 = {name: 'Mary'};
- * const obj3 = {name: 'Jack'};
- * const arr = [obj1, obj2, obj3];
- * const strArr = ['Alex', 'Mary', 'Jack'];
- *
- * // Handler for comparison
- * arr.filter(cnd(obj => obj.name === 'Alex')); // [{name: 'Alex'}]
- *
- * // Strict value comparison
- * arr.filter(cnd({is: obj1})); // [{name: 'Alex'}]
- * arr.filter(cnd({is: {name: 'Alex'}})); // []
- * arr.filter(cnd({or: [obj1, obj2]})); // [{name: 'Alex'}, {name: 'Mary'}]
- * arr.filter(cnd({or: [{name: 'Alex'}, obj2]})); // [{name: 'Mary'}]
- * arr.filter(cnd({not: [obj1, obj2]})); // [{name: 'Jack'}]
- * arr.filter(cnd({not: [{name: 'Alex'}, obj2]})); // [{name: 'Alex'}, {name: 'Jack'}]
- *
- * // Value equivalence comparison
- * arr.filter(cnd({equal: obj1})); // [{name: 'Alex'}]
- * arr.filter(cnd({equal: {name: 'Alex'}})); // [{name: 'Alex'}]
- * arr.filter(cnd({orEqual: [obj1, obj2]})); // [{name: 'Alex'}, {name: 'Mary'}]
- * arr.filter(cnd({orEqual: [{name: 'Alex'}, obj2]})); // [{name: 'Alex'}, {name: 'Mary'}]
- * arr.filter(cnd({notEqual: [obj1, obj2]})); // [{name: 'Jack'}]
- * arr.filter(cnd({notEqual: [{name: 'Alex'}, obj2]})); // [{name: 'Jack'}]
- *
- * // String value RegExp comparison
- * strArr.filter(cnd({equal: /^Alex$/})); // ['Alex']
- * strArr.filter(cnd({orEqual: [/^Alex$/, /^Mary$/]})); // ['Alex', 'Mary']
- * strArr.filter(cnd({notEqual: [/^Alex$/, /^Mary$/]})); // ['Jack']
- *
- * // Strict comparison of field value in objects
- * arr.filter(cnd({name: {is: 'Alex'}})); // [{name: 'Alex'}]
- * arr.filter(cnd({name: {or: ['Alex', 'Mary']}})); // [{name: 'Alex'}, {name: 'Mary'}]
- * arr.filter(cnd({name: {not: ['Alex', 'Mary']}})); // [{name: 'Jack'}]
- *
- * // Comparison of field value equivalence in objects
- * arr.filter(cnd({name: {equal: 'Alex'}})); // [{name: 'Alex'}]
- * arr.filter(cnd({name: {orEqual: ['Alex', 'Mary']}})); // [{name: 'Alex'}, {name: 'Mary'}]
- * arr.filter(cnd({name: {notEqual: ['Alex', 'Mary']}})); // [{name: 'Jack'}]
- *
- * // Comparing string fields in objects using RegExp
- * arr.filter(cnd({name: /^Alex$/})); // [{name: 'Alex'}]
- * arr.filter(cnd({name: {equal: /^Alex$/}})); // [{name: 'Alex'}]
- * arr.filter(cnd({name: {orEqual: [/^Alex$/, /^Mary$/]}})); // [{name: 'Alex'}, {name: 'Mary'}]
- * arr.filter(cnd({name: {notEqual: [/^Alex$/, /^Mary$/]}})); // [{name: 'Jack'}]
- *
- * @param conditions
- */
-export declare function cnd(conditions: MatchConditions): MatchConditionFn;

package/arr/cnd/cnd.js

@@ -1,136 +0,0 @@
-import { BfError, isFunction, isObject, isRegExp, isString, same, equals, isArray } from '../../';
-import { hasOwn } from '../../obj';
-/**
- * Returns a function that checks if a value matches the conditions
- * @example
- * import {cnd} from '@bitfiber/utils/arr';
- *
- * const obj1 = {name: 'Alex'};
- * const obj2 = {name: 'Mary'};
- * const obj3 = {name: 'Jack'};
- * const arr = [obj1, obj2, obj3];
- * const strArr = ['Alex', 'Mary', 'Jack'];
- *
- * // Handler for comparison
- * arr.filter(cnd(obj => obj.name === 'Alex')); // [{name: 'Alex'}]
- *
- * // Strict value comparison
- * arr.filter(cnd({is: obj1})); // [{name: 'Alex'}]
- * arr.filter(cnd({is: {name: 'Alex'}})); // []
- * arr.filter(cnd({or: [obj1, obj2]})); // [{name: 'Alex'}, {name: 'Mary'}]
- * arr.filter(cnd({or: [{name: 'Alex'}, obj2]})); // [{name: 'Mary'}]
- * arr.filter(cnd({not: [obj1, obj2]})); // [{name: 'Jack'}]
- * arr.filter(cnd({not: [{name: 'Alex'}, obj2]})); // [{name: 'Alex'}, {name: 'Jack'}]
- *
- * // Value equivalence comparison
- * arr.filter(cnd({equal: obj1})); // [{name: 'Alex'}]
- * arr.filter(cnd({equal: {name: 'Alex'}})); // [{name: 'Alex'}]
- * arr.filter(cnd({orEqual: [obj1, obj2]})); // [{name: 'Alex'}, {name: 'Mary'}]
- * arr.filter(cnd({orEqual: [{name: 'Alex'}, obj2]})); // [{name: 'Alex'}, {name: 'Mary'}]
- * arr.filter(cnd({notEqual: [obj1, obj2]})); // [{name: 'Jack'}]
- * arr.filter(cnd({notEqual: [{name: 'Alex'}, obj2]})); // [{name: 'Jack'}]
- *
- * // String value RegExp comparison
- * strArr.filter(cnd({equal: /^Alex$/})); // ['Alex']
- * strArr.filter(cnd({orEqual: [/^Alex$/, /^Mary$/]})); // ['Alex', 'Mary']
- * strArr.filter(cnd({notEqual: [/^Alex$/, /^Mary$/]})); // ['Jack']
- *
- * // Strict comparison of field value in objects
- * arr.filter(cnd({name: {is: 'Alex'}})); // [{name: 'Alex'}]
- * arr.filter(cnd({name: {or: ['Alex', 'Mary']}})); // [{name: 'Alex'}, {name: 'Mary'}]
- * arr.filter(cnd({name: {not: ['Alex', 'Mary']}})); // [{name: 'Jack'}]
- *
- * // Comparison of field value equivalence in objects
- * arr.filter(cnd({name: {equal: 'Alex'}})); // [{name: 'Alex'}]
- * arr.filter(cnd({name: {orEqual: ['Alex', 'Mary']}})); // [{name: 'Alex'}, {name: 'Mary'}]
- * arr.filter(cnd({name: {notEqual: ['Alex', 'Mary']}})); // [{name: 'Jack'}]
- *
- * // Comparing string fields in objects using RegExp
- * arr.filter(cnd({name: /^Alex$/})); // [{name: 'Alex'}]
- * arr.filter(cnd({name: {equal: /^Alex$/}})); // [{name: 'Alex'}]
- * arr.filter(cnd({name: {orEqual: [/^Alex$/, /^Mary$/]}})); // [{name: 'Alex'}, {name: 'Mary'}]
- * arr.filter(cnd({name: {notEqual: [/^Alex$/, /^Mary$/]}})); // [{name: 'Jack'}]
- *
- * @param conditions
- */
-export function cnd(conditions) {
-    if (isFunction(conditions)) {
-        return conditions;
-    }
-    else if ('is' in conditions) {
-        return value => same(conditions.is, value);
-    }
-    else if ('or' in conditions) {
-        return value => (isArray(conditions.or) ? conditions.or.some(item => same(item, value)) : cndErr());
-    }
-    else if ('not' in conditions) {
-        return value => (isArray(conditions.not) ? !conditions.not.some(item => same(item, value)) : cndErr());
-    }
-    else if ('equal' in conditions) {
-        return value => fit(conditions.equal, value);
-    }
-    else if ('orEqual' in conditions) {
-        return value => (isArray(conditions.orEqual) ? conditions.orEqual.some(item => fit(item, value)) : cndErr());
-    }
-    else if ('notEqual' in conditions) {
-        return value => (isArray(conditions.notEqual) ? !conditions.notEqual.some(item => fit(item, value)) : cndErr());
-    }
-    else {
-        return obj => {
-            if (isObject(obj)) {
-                for (const key in conditions) {
-                    if (hasOwn(conditions, key)) {
-                        const value = obj[key];
-                        const condition = conditions[key];
-                        if (isRegExp(condition)) {
-                            if (!fit(condition, value)) {
-                                return false;
-                            }
-                        }
-                        else if ('is' in condition) {
-                            if (!same(condition.is, value)) {
-                                return false;
-                            }
-                        }
-                        else if ('or' in condition) {
-                            if (!condition.or.some(item => same(item, value))) {
-                                return false;
-                            }
-                        }
-                        else if ('not' in condition) {
-                            if (condition.not.some(item => same(item, value))) {
-                                return false;
-                            }
-                        }
-                        else if ('equal' in condition) {
-                            if (!fit(condition.equal, value)) {
-                                return false;
-                            }
-                        }
-                        else if ('orEqual' in condition) {
-                            if (!condition.orEqual.some(item => fit(item, value))) {
-                                return false;
-                            }
-                        }
-                        else if ('notEqual' in condition) {
-                            if (condition.notEqual.some(item => fit(item, value))) {
-                                return false;
-                            }
-                        }
-                    }
-                }
-                return true;
-            }
-            else {
-                return false;
-            }
-        };
-    }
-}
-function fit(condition, value) {
-    return isRegExp(condition) ? isString(value) && condition.test(value) : equals(condition, value);
-}
-function cndErr() {
-    throw new BfError('"or", "not", "orEqual" and "notEqual" must be an array', { code: 'bf_utils_arr_cnd_1' });
-}
-//# sourceMappingURL=cnd.js.map