Issue #44 Export intersection function from lodash

Added lodash intersection and intersectionWith to CollectionUtils

Author: brandongregoryscott

src/utilities/collection-utils.test.ts

@@ -398,7 +398,7 @@ describe("CollectionUtils", () => {
             const result = CollectionUtils.equalsBy(selector, arr1, arr2);
 
             // Assert
-            expect(result).toBe(false);
+            expect(result).toBeFalse();
         });
 
         it("when one of the collections is null, then returns false", () => {
@@ -409,7 +409,7 @@ describe("CollectionUtils", () => {
             const result = CollectionUtils.equalsBy(selector, arr1, undefined);
 
             // Assert
-            expect(result).toBe(false);
+            expect(result).toBeFalse();
         });
 
         it("when both collections are null, then returns true", () => {
@@ -421,7 +421,7 @@ describe("CollectionUtils", () => {
             );
 
             // Assert
-            expect(result).toBe(true);
+            expect(result).toBeTrue();
         });
 
         it("when collections are equal size but contain different elements, then returns false", () => {
@@ -433,7 +433,7 @@ describe("CollectionUtils", () => {
             const result = CollectionUtils.equalsBy(selector, arr1, arr2);
 
             // Assert
-            expect(result).toBe(false);
+            expect(result).toBeFalse();
         });
 
         it("when collections are identical, then returns true", () => {
@@ -445,7 +445,7 @@ describe("CollectionUtils", () => {
             const result = CollectionUtils.equalsBy(selector, arr1, arr2);
 
             // Assert
-            expect(result).toBe(true);
+            expect(result).toBeTrue();
         });
     });
 

src/utilities/collection-utils.ts

@@ -1,6 +1,7 @@
-import { List } from "immutable";
+import * as Immutable from "immutable";
 import _ from "lodash";
 
+
 // -----------------------------------------------------------------------------------------
 // #region Private Methods
 // -----------------------------------------------------------------------------------------
@@ -18,8 +19,8 @@ import _ from "lodash";
  */
 const _equalsBy = function<T, V>(
     selector: (element: T) => V,
-    array1: Array<T> | List<any> | undefined,
-    array2: Array<T> | List<any> | undefined
+    array1: Array<T> | Immutable.List<any> | undefined,
+    array2: Array<T> | Immutable.List<any> | undefined
 ) {
     if (array1 == null) {
         return array2 == null;
@@ -44,22 +45,46 @@ const _equalsBy = function<T, V>(
     return !hasDifferingValues;
 };
 
+
+/**
+ * Creates an array of unique array values not included in the other provided arrays using SameValueZero for
+ * equality comparisons.
+ *
+ * @param array The array to inspect.
+ * @param values The arrays of values to exclude.
+ * @return Returns the new array of filtered values.
+ */
+const _difference = <T>(
+    array: Array<T> | null | undefined,
+    ...values: Array<Array<T>>
+): T[] => _.difference(array, ...values);
+
+
+/**
+ * Recursively flattens a nested array.
+ *
+ * @param array The array to recursively flatten.
+ * @return Returns the new flattened array.
+ */
+const _flattenDeep = <T>(array: Array<T> | null | undefined): T[] => _.flattenDeep(array);
+
+
 /**
  * Checks for values in a collection/object. Returns false if the collection is undefined, null,
  * or the respective object type's "empty" state, ie length 0, size 0, or has no keys.
  *
  * Uses ... syntax to allow a single collection or multiple collections to be passed in, ie
  * CollectionUtils.hasValues([]) or CollectionUtils.hasValues([], [], [])
  *
- * @param {(...Array<(any[] | List<any>)} collections
+ * @param {(...Array<(any[] | Immutable.List<any>)} collections
  * @returns {boolean} False if `collections` is null/undefined, or every element is also null/undefined,
  * or has no sub-elements. True if any element has sub-elements.
  */
 const _hasValues = (
-    ...collections: Array<any[] | List<any> | undefined>
+    ...collections: Array<any[] | Immutable.List<any> | undefined>
 ): boolean => {
     let hasValues = false;
-    collections.forEach((collection: any[] | List<any> | undefined) => {
+    collections.forEach((collection: any[] | Immutable.List<any> | undefined) => {
         if (!_isEmpty(collection)) {
             hasValues = true;
         }
@@ -74,21 +99,21 @@ const _hasValues = (
  * Uses ... syntax to allow a single collection or multiple collections to be passed in, ie
  * CollectionUtils.isEmpty([]) or CollectionUtils.isEmpty([], [], [])
  *
- * @param {(...Array<(any[] | List<any>)} collections
+ * @param {(...Array<(any[] | Immutable.List<any>)} collections
  * @returns {boolean} True if `collections` is null/undefined, or every element is also null/undefined,
  * or has no sub-elements. False if any element has sub-elements.
  */
 const _isEmpty = (
-    ...collections: Array<any[] | List<any> | undefined>
+    ...collections: Array<any[] | Immutable.List<any> | undefined>
 ): boolean => {
     let isEmpty = true;
 
-    collections.forEach((collection: any[] | List<any> | undefined) => {
+    collections.forEach((collection: any[] | Immutable.List<any> | undefined) => {
         if (collection == null) {
             return;
         }
-        if (collection instanceof List) {
-            const collectionList = collection as List<any>;
+        if (collection instanceof Immutable.List) {
+            const collectionList = collection as Immutable.List<any>;
             if (collectionList.size !== 0) {
                 isEmpty = false;
             }
@@ -110,34 +135,82 @@ const _isEmpty = (
  * Uses ... syntax to allow a single collection or multiple collections to be passed in, ie
  * CollectionUtils.isNotEmpty([]) or CollectionUtils.isNotEmpty([], [], [])
  *
- * @param {(...Array<(any[] | List<any>)} collections
+ * @param {(...Array<(any[] | Immutable.List<any>)} collections
  * @returns {boolean} False if `collections` is null/undefined, or every element is also null/undefined,
  * or has no sub-elements. True if any element has sub-elements.
  */
 const _isNotEmpty = (
-    ...collections: Array<any[] | List<any> | undefined>
+    ...collections: Array<any[] | Immutable.List<any> | undefined>
 ): boolean => {
     return !_isEmpty(...collections);
 };
 
 /**
  * Utility function to get the length of a collection
- * when the collection might be either a List or an Array
+ * when the collection might be either a Immutable.List or an Array
  * @param arr the collection
  * @returns number the length of the collection
  */
-const _length = (arr: Array<any> | List<any>): number => {
+const _length = (arr: Array<any> | Immutable.List<any>): number => {
     if (arr == null) {
         return -1;
     }
 
-    if (arr instanceof List) {
-        return (arr as List<any>).size;
+    if (arr instanceof Immutable.List) {
+        return (arr as Immutable.List<any>).size;
     }
 
     return (arr as Array<any>).length;
 };
 
+
+/**
+ * Gets the first element of array.
+ *
+ * @alias _.first
+ *
+ * @param array The array to query.
+ * @return Returns the first element of array.
+ */
+const _head = <T>(array: Array<T> | null | undefined): T | undefined => _.head(array);
+
+
+/**
+ * Creates an array of  unique values that are included in all of the provided arrays using SameValueZero for
+ * equality comparisons.
+ *
+ * @param arrays The arrays to inspect.
+ * @return Returns the new array of shared values.
+ */
+const _intersection = <T>(...arrays: Array<Array<T>>) => _.intersection(...arrays)
+
+
+
+/**
+ * Creates an array of unique `array` values not included in the other
+ * provided arrays using [`SameValueZero`](http://ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
+ * for equality comparisons.
+ *
+ * @category Array
+ * @param array
+ * @param [values] The arrays to inspect.
+ * @param [comparator] The comparator invoked per element.
+ * @returns Returns the new array of filtered values.
+ * @example
+ *
+ * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];
+ * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];
+
+ * _.intersectionWith(objects, others, _.isEqual);
+ * => [{ 'x': 1, 'y': 2 }]
+ */
+const _intersectionWith = <T1, T2>(
+    array: Array<T1>,
+    values: Array<T2>,
+    comparator: (a: T1, b: T2) => boolean
+): T1[] => _.intersectionWith(array, values, comparator);
+
+
 /**
  * Removes a supplied element by index
  * @param source original array
@@ -153,6 +226,7 @@ const _removeElementAt = <T>(source: Array<T>, index: number): Array<T> => {
     return newArr;
 };
 
+
 /**
  * Returns a NEW array with the element at the specified index
  * replaced with the specified value if the index provided is
@@ -182,6 +256,29 @@ const _replaceElementAt = <T>(
     return [...source.slice(0, index), value, ...source.slice(index + 1)];
 };
 
+/**
+ * Gets a random element from collection.
+ *
+ * @param collection The collection to sample.
+ * @return Returns the random element.
+ */
+const _sample = <T>(
+    collection: Array<T> | null | undefined
+): T | undefined => _.sample(collection);
+
+
+/**
+ * Gets n random elements at unique keys from collection up to the size of collection.
+ *
+ * @param collection The collection to sample.
+ * @param n The number of elements to sample.
+ * @return Returns the random elements.
+ */
+const _sampleSize = <T>(
+    collection: Array<T> | null | undefined,
+    n?: number
+): T[] => _.sampleSize(collection, n);
+
 /**
  * Sort an array of items alphabetically by one property of the item.
  * @param array the source array of items
@@ -220,6 +317,18 @@ const _sortByString = <T extends any>(
 
         return 1;
     });
+            
+  /**
+ * Creates a slice of array with n elements taken from the beginning.
+ *
+ * @param array The array to query.
+ * @param n The number of elements to take.
+ * @return Returns the slice of array.
+ */
+const _take = <T>(
+    array: Array<T> | null | undefined,
+    n?: number
+): T[] => _.take(array, n);
 
 // #endregion Private Methods
 
@@ -228,20 +337,22 @@ const _sortByString = <T extends any>(
 // -----------------------------------------------------------------------------------------
 
 export const CollectionUtils = {
-    difference: _.difference,
+    difference: _difference,
     equalsBy: _equalsBy,
-    first: _.head,
-    flattenDeep: _.flattenDeep,
+    first: _head,
+    flattenDeep: _flattenDeep,
     hasValues: _hasValues,
     isEmpty: _isEmpty,
     isNotEmpty: _isNotEmpty,
+    intersection: _intersection,
+    intersectionWith: _intersectionWith,
     length: _length,
     removeElementAt: _removeElementAt,
     replaceElementAt: _replaceElementAt,
-    sample: _.sample,
-    sampleSize: _.sampleSize,
+    sample: _sample,
+    sampleSize: _sampleSize,
     sortByString: _sortByString,
-    take: _.take,
+    take: _take,
 };
 
 // #endregion Exports