@bitfiber/utils 1.0.1 → 1.0.3

package/dist/obj/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/obj/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAC,MAAM,mBAAmB,CAAC;AACzC,OAAO,EAAC,UAAU,EAAC,MAAM,6BAA6B,CAAC;AACvD,OAAO,EAAC,IAAI,EAAC,MAAM,aAAa,CAAC;AACjC,OAAO,EAAC,MAAM,EAAC,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAC,OAAO,EAAC,MAAM,mBAAmB,CAAC;AAC1C,OAAO,EAAC,OAAO,EAAC,MAAM,mBAAmB,CAAC;AAC1C,OAAO,EAAC,QAAQ,EAAC,MAAM,qBAAqB,CAAC;AAC7C,OAAO,EAAC,YAAY,EAAC,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAC,MAAM,EAAC,MAAM,mBAAmB,CAAC;AACzC,OAAO,EAAC,WAAW,EAAC,MAAM,iCAAiC,CAAC;AAC5D,OAAO,EAAC,OAAO,EAAU,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAC,MAAM,EAAE,SAAS,EAAC,MAAM,iBAAiB,CAAC"}

package/{obj → dist/obj}/keys/keys.d.ts

@@ -1,4 +1,4 @@
-import { Obj } from '../../';
+import { Obj } from '../../common';
 /**
  * Returns an array of the object's own enumerable property names
  * @param obj - any object

package/dist/obj/keys/keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keys.js","sourceRoot":"","sources":["../../../src/obj/keys/keys.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,UAAU,IAAI,CAAgB,GAAM;IACxC,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC1B,CAAC"}

package/{obj → dist/obj}/map-obj/map-obj.d.ts

@@ -1,4 +1,4 @@
-import { Obj, ValueUnion } from '../../';
+import { Obj, ValueUnion } from '../../common';
 /**
  * Returns a new object, which has the mapped values of object fields
  * @param obj - any object

package/dist/obj/map-obj/map-obj.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-obj.js","sourceRoot":"","sources":["../../../src/obj/map-obj/map-obj.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,UAAU,EAAC,MAAM,KAAK,CAAC;AAE/B;;;;GAIG;AACH,MAAM,UAAU,MAAM,CAAsC,GAAM,EAChE,OAAoD;IACpD,MAAM,MAAM,GAAiB,EAAE,CAAC;IAChC,UAAU,CAAC,GAAG,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC,MAAM,CAAI,GAAG,CAAC,GAAG,OAAO,CAAC,KAAK,EAAK,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;IAC9E,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/{obj → dist/obj}/map-obj-to-arr/map-obj-to-arr.d.ts

@@ -1,4 +1,4 @@
-import { Obj, ValueUnion } from '../../';
+import { Obj, ValueUnion } from '../../common';
 /**
  * Returns an array, which has the mapped values of object fields
  * @param obj - any object

package/dist/obj/map-obj-to-arr/map-obj-to-arr.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-obj-to-arr.js","sourceRoot":"","sources":["../../../src/obj/map-obj-to-arr/map-obj-to-arr.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,UAAU,EAAC,MAAM,KAAK,CAAC;AAE/B;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAsC,GAAM,EACrE,OAAoD;IACpD,MAAM,MAAM,GAAQ,EAAE,CAAC;IACvB,UAAU,CAAC,GAAG,EAAE,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAK,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;IAC1E,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/{obj → dist/obj}/values/values.d.ts

@@ -1,4 +1,4 @@
-import { Obj } from '../../';
+import { Obj } from '../../common';
 /**
  * Returns an array of values for each object's own enumerable property
  * @param obj - any object

package/dist/obj/values/values.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"values.js","sourceRoot":"","sources":["../../../src/obj/values/values.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,UAAU,EAAC,MAAM,KAAK,CAAC;AAE/B;;;GAGG;AACH,MAAM,UAAU,MAAM,CAAI,GAAW;IACnC,MAAM,MAAM,GAAQ,EAAE,CAAC;IACvB,UAAU,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAC7C,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/str/index.d.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/dist/str/index.js

@@ -0,0 +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';
+//# sourceMappingURL=index.js.map

package/dist/str/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/str/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAC,MAAM,6BAA6B,CAAC;AACxD,OAAO,EAAC,WAAW,EAAC,MAAM,+BAA+B,CAAC;AAC1D,OAAO,EAAC,MAAM,EAAC,MAAM,mBAAmB,CAAC"}

package/dist/str/to-camel-case/to-camel-case.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-camel-case.js","sourceRoot":"","sources":["../../../src/str/to-camel-case/to-camel-case.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,UAAU,WAAW,CAAC,GAAW,EAAE,aAAuB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC;IAC7E,OAAO,UAAU,CAAC,MAAM,CAAC,CAAC,GAAW,EAAE,SAAiB,EAAE,EAAE;QAC1D,MAAM,GAAG,GAAG,IAAI,MAAM,CAAC,SAAS,GAAG,YAAY,EAAE,IAAI,CAAC,CAAC;QACvD,OAAO,GAAG,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,GAAW,EAAE,MAAc,EAAE,EAAE;YACtD,OAAO,MAAM,CAAC,WAAW,EAAE,CAAC;QAC9B,CAAC,CAAC,CAAC;IACL,CAAC,EAAE,GAAG,CAAC,CAAC;AACV,CAAC"}

package/dist/str/to-hash/to-hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-hash.js","sourceRoot":"","sources":["../../../src/str/to-hash/to-hash.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,UAAU,MAAM,CAAC,GAAW;IAChC,IAAI,GAAG,EAAE;QACP,IAAI,IAAI,GAAG,CAAC,CAAC;QAEb,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACnC,MAAM,IAAI,GAAG,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;YAC/B,IAAI,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC;YACnC,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;SACpB;QAED,OAAO,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,IAAI,CAAC;KACvD;SAAM;QACL,OAAO,EAAE,CAAC;KACX;AACH,CAAC"}

package/dist/str/with-capital/with-capital.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-capital.js","sourceRoot":"","sources":["../../../src/str/with-capital/with-capital.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,GAAW;IACrC,OAAO,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;AACxD,CAAC"}

package/package.json

@@ -1,73 +1,71 @@
-{
-  "name": "@bitfiber/utils",
-  "description": "Collection of versatile utility functions for Javascript",
-  "version": "1.0.1",
-  "type": "module",
-  "module": "./src/index.js",
-  "main": "./index.js",
-  "types": "./index.d.ts",
-  "typesVersions": {
-    ">=4.8.2": {
-      "*": [
-        "*.d.ts"
-      ]
-    }
-  },
-  "sideEffects": false,
-  "exports": {
-    ".": {
-      "types": "./index.d.ts",
-      "default": "./index.js"
-    },
-    "./arr": {
-      "types": "./arr/index.d.ts",
-      "default": "./arr/index.js"
-    },
-    "./obj": {
-      "types": "./obj/index.d.ts",
-      "default": "./obj/index.js"
-    },
-    "./str": {
-      "types": "./str/index.d.ts",
-      "default": "./str/index.js"
-    },
-    "./num": {
-      "types": "./num/index.d.ts",
-      "default": "./num/index.js"
-    },
-    "./dom": {
-      "types": "./dom/index.d.ts",
-      "default": "./dom/index.js"
-    },
-    "./env": {
-      "types": "./env/index.d.ts",
-      "default": "./env/index.js"
-    },
-    "./package.json": "./package.json"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/bitfiber/utils.git",
-    "directory": "utils"
-  },
-  "keywords": [
-    "Javascript",
-    "Typescript",
-    "Utils",
-    "Utilities",
-    "Helpers"
-  ],
-  "author": {
-    "name": "Zmanovskyi Oleksandr",
-    "email": "bitfiber.web@gmail.com"
-  },
-  "license": "Apache 2.0",
-  "bugs": {
-    "url": "https://github.com/bitfiber/utils/issues"
-  },
-  "homepage": "https://github.com/bitfiber/utils",
-  "dependencies": {
-    "tslib": "^2.3.0"
-  },
-  "peerDependencies": {}
-}
+{
+  "name": "@bitfiber/utils",
+  "description": "Collection of versatile utility functions for Javascript",
+  "version": "1.0.3",
+  "type": "module",
+  "module": "./dist/index.js",
+  "main": "./dist/index.js",
+  "types": "index.d.ts",
+  "typesVersions": {
+    ">=4.8.2": {
+      "*": ["dist/*"]
+    }
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./arr": {
+      "types": "./dist/arr/index.d.ts",
+      "default": "./dist/arr/index.js"
+    },
+    "./obj": {
+      "types": "./dist/obj/index.d.ts",
+      "default": "./dist/obj/index.js"
+    },
+    "./str": {
+      "types": "./dist/str/index.d.ts",
+      "default": "./dist/str/index.js"
+    },
+    "./num": {
+      "types": "./dist/num/index.d.ts",
+      "default": "./dist/num/index.js"
+    },
+    "./dom": {
+      "types": "./dist/dom/index.d.ts",
+      "default": "./dist/dom/index.js"
+    },
+    "./env": {
+      "types": "./dist/env/index.d.ts",
+      "default": "./dist/env/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bitfiber/utils.git",
+    "directory": "utils"
+  },
+  "keywords": [
+    "Javascript",
+    "Typescript",
+    "Utils",
+    "Utilities",
+    "Helpers"
+  ],
+  "author": {
+    "name": "Oleksandr Zmanovskyi",
+    "email": "bitfiber.web@gmail.com"
+  },
+  "license": "Apache 2.0",
+  "bugs": {
+    "url": "https://github.com/bitfiber/utils/issues"
+  },
+  "homepage": "https://github.com/bitfiber/utils",
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "peerDependencies": {}
+}

package/src/arr/at/at.ts

@@ -0,0 +1,10 @@
+/**
+ * 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<T>(arr: T[], index: number): T | undefined {
+  // todo: change on 'Array.at' with ES2022
+  return index < 0 ? arr[arr.length + index] : arr[index];
+}

package/src/arr/cnd/cnd.ts

@@ -0,0 +1,188 @@
+import {BfError, isFunction, isObject, isRegExp, isString, same, equals, isArray} from '../../common';
+import {hasOwn} from '../../obj';
+
+/**
+ * Represents a condition that is true if the function returns true
+ * Used for the cnd function
+ */
+export type MatchConditionFn = (value: any) => boolean;
+
+/**
+ * Represents a condition that is true if the value is the same as the condition
+ * Used for the cnd function
+ */
+export type MatchConditionIs = {is: any};
+
+/**
+ * Represents a condition that is true if the value is the same for at least one part of the condition
+ * Used for the cnd function
+ */
+export type MatchConditionOr = {or: any[]};
+
+/**
+ * Represents a condition that is true if the value is not the same for each part of the condition
+ * Used for the cnd function
+ */
+export type MatchConditionNot = {not: any[]};
+
+/**
+ * Represents a condition that is true if the value is equal to the condition
+ * Used for the cnd function
+ */
+export type MatchConditionEqual = {equal: any};
+
+/**
+ * Represents a condition that is true if the value is equal to at least one part of the condition
+ * Used for the cnd function
+ */
+export type MatchConditionOrEqual = {orEqual: any[]};
+
+/**
+ * Represents a condition that is true if the value is not equal to each part of the condition
+ * Used for the cnd function
+ */
+export type MatchConditionNotEqual = {notEqual: any[]};
+
+/**
+ * Represents a group of all object condition types
+ * Used for the cnd function
+ */
+export type MatchConditionObj = MatchConditionIs | MatchConditionOr | MatchConditionNot | MatchConditionEqual
+  | MatchConditionOrEqual | MatchConditionNotEqual;
+
+/**
+ * Represents a condition that is true if the value of each field matches each field condition
+ * Used for the cnd function
+ */
+export type MatchConditionsByFields = {
+  [field: string]: MatchConditionObj | RegExp;
+};
+
+/**
+ * Represents all condition types for the cnd function
+ */
+export type MatchConditions = MatchConditionFn | MatchConditionObj | MatchConditionsByFields;
+
+/**
+ * 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: MatchConditions): MatchConditionFn {
+  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: any, value: any): boolean {
+  return isRegExp(condition) ? isString(value) && condition.test(value) : equals(condition, value);
+}
+
+function cndErr(): never {
+  throw new BfError('"or", "not", "orEqual" and "notEqual" must be an array', {code: 'bf_utils_arr_cnd_1'});
+}

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

@@ -0,0 +1,66 @@
+import {NumStr} from '../../common';
+
+/**
+ * Represents response of the diffArr function
+ */
+export interface ArrDiff<T> {
+
+  /**
+   * Contains items that are only in array 1
+   */
+  only1: T[];
+
+  /**
+   * Contains items that are only in array 2
+   */
+  only2: T[];
+
+  /**
+   * Contains items that are in both arrays
+   */
+  equal: T[];
+
+  /**
+   * True if only1 and only2 are empty, otherwise false
+   */
+  isEqual: boolean;
+}
+
+/**
+ * Returns the difference between two arrays
+ * Strict comparison of array items is applied
+ * The order doesn't matter
+ * @param arr1 - array 1
+ * @param arr2 - array 2
+ */
+export function diffArr<T extends NumStr>(arr1: T[], arr2: T[]): ArrDiff<T> {
+  let isEqual = true;
+  const only1: T[] = [];
+  const only2: T[] = [];
+  const equal: T[] = [];
+  const map1 = new Map(arr1.map(value => [value, true]));
+  const map2 = new Map(arr2.map(value => [value, true]));
+
+  for (const value of map1.keys()) {
+    if (!map2.has(value)) {
+      isEqual = false;
+      only1.push(value);
+    } else {
+      equal.push(value);
+    }
+  }
+
+  for (const value of map2.keys()) {
+    if (!map1.has(value)) {
+      isEqual = false;
+      only2.push(value);
+    }
+  }
+
+  return {
+    only1,
+    only2,
+    equal,
+    isEqual,
+  };
+}

package/src/arr/fill/fill.ts

@@ -0,0 +1,10 @@
+/**
+ * Fills a new array with items that will be returned by the handler,
+ * which will be called a certain number of times
+ * @param quantity - number of array items
+ * @param handler - a function that should return a new array item
+ * @param offset - offset for the index, which is passed to the handler
+ */
+export function fill<T>(quantity: number, handler: (offsetIndex: number, index: number) => T, offset = 1): T[] {
+  return Array(quantity).fill(null).map((item, index) => handler(index + offset, index));
+}

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

@@ -0,0 +1,25 @@
+import {Arr, INTERRUPT, ValueUnion} from '../../common';
+
+/**
+ * Iterates through all the items of an array and calls a handler for each item
+ * If the handler returns INTERRUPT, the loop will be interrupted
+ * @param arr - an array or any typed array
+ * @param handler - function called for each item
+ * @param reverse - iterates in reverse order if true
+ */
+export function forEachArr<T extends Arr, V extends ValueUnion<T>>(arr: T,
+  handler: (value: V, index: number, arr: T) => any, reverse?: boolean): void {
+  if (reverse) {
+    for (let i = arr.length - 1; i >= 0; i--) {
+      if (handler(arr[i], i, arr) === INTERRUPT) {
+        return;
+      }
+    }
+  } else {
+    for (let i = 0; i < arr.length; i++) {
+      if (handler(arr[i], i, arr) === INTERRUPT) {
+        return;
+      }
+    }
+  }
+}

package/src/arr/index-by/index-by.ts

@@ -0,0 +1,19 @@
+import {isFunction, Obj, Index} from '../../common';
+
+/**
+ * Returns an object indexed by the values from a specific field of each item
+ * or from a function that is executed on each item
+ * @param arr - array of objects
+ * @param fieldOrFn - the name of the field from which the index value should be taken,
+ * or the function that should return the index value
+ */
+export function indexBy<T extends Obj>(arr: T[], fieldOrFn: string | ((item: T) => string)): Index<T> {
+  const result: Index<T> = {};
+  arr.forEach(item => {
+    const key = isFunction(fieldOrFn) ? fieldOrFn(item) : item[fieldOrFn];
+    if (key) {
+      result[key] = item;
+    }
+  });
+  return result;
+}

package/src/arr/index.ts

@@ -0,0 +1,11 @@
+export {at} from './at/at';
+export {within} from './within/within';
+export {pluck} from './pluck/pluck';
+export {indexBy} from './index-by/index-by';
+export {fill} from './fill/fill';
+export {diffArr, ArrDiff} from './diff-arr/diff-arr';
+export {forEachArr} from './for-each-arr/for-each-arr';
+export {
+  cnd, MatchConditionFn, MatchConditionIs, MatchConditionOr, MatchConditionNot, MatchConditionEqual,
+  MatchConditionOrEqual, MatchConditionNotEqual, MatchConditionObj, MatchConditionsByFields, MatchConditions,
+} from './cnd/cnd';

package/src/arr/pluck/pluck.ts

@@ -0,0 +1,14 @@
+import {Obj} from '../../common';
+
+/**
+ * Returns an array with values, each of which corresponds to the value of a certain array item field
+ * @param arr - array of objects
+ * @param fieldName - name of the array item field from which the value is to be taken
+ */
+export function pluck<T extends Obj, F extends keyof T>(arr: T[], fieldName: F): (T[F])[] {
+  const result: (T[F])[] = [];
+  arr.forEach(item => {
+    result.push(item[fieldName]);
+  });
+  return result;
+}

package/src/arr/within/within.ts

@@ -0,0 +1,14 @@
+import {at} from '../';
+
+/**
+ * Returns an array item by index.
+ * If the index is greater than the array length,
+ * then the array item will be obtained like remainder of division the index by the array length.
+ * For negative indexes, returns items from the end
+ * @param arr - any array
+ * @param index - an array item index
+ */
+export function within<T>(arr: T[], index: number): T | undefined {
+  const max = arr.length;
+  return at(arr, ((index + 1) % max || max) - 1);
+}