some-common-functions-js 1.0.9 → 1.1.2

package/CHANGELOG.md

@@ -28,8 +28,20 @@ Improve README.md documentation.
 - Corrected README documentation.
 
 ## Version 1.0.8 - 2025/11/21 - ITA
-- Corrected test code and README documentation
+- Corrected test code and README documentation.
 
 ## Version 1.0.9 - 2025/11/28 - ITA
 - Provided more documentation in test.js to remind a developer how to symbolic-link (mimick as installed) the package and running the test code.
 - Added new function, hasOnlyAll(), and updated the README.md documentation accordingly.
+  
+## Version 1.1.0 - 2025/12/22 - ITA
+- Improved documentation.
+- Moved in more functions to the package: `deepClone(anObject)`, `getSortedObject(anObject)`, `timeStampYyyyMmDd(dateInstance)` and `timeStampString(dateInstance)`.
+  
+## Version 1.1.1 - 2025/12/26 - ITA
+- Removed lodash dependency and re-implemented the get() and set() object functions, reducing package size.
+- Re-implemented the getSortedObj() function to no longer use the get() object function.
+- Improved the duplicate removal process in getArrayWithNoDuplicates() function, so as to be more reliable across all cases. Implemented the new getNextDifferentObject() function in the light of that.
+
+## Version 1.1.2 - 2025/12/26 - ITA
+Corrected a minor error in the README documentation.

package/README.md

@@ -1,17 +1,23 @@
-# JavaScript Object Utilities & Field Validation Functions
+# JavaScript Object Utilities, Field Validation Functions, Array Binary Search, and Date timestamp Functions.
 
 Common functions used for working with JavaScript objects and validating field values.
 
 ---
 ## Installation
-**npm install some-common-functions-js**
-
+```
+npm install some-common-functions-js
+```  
+  
 ## 1. JavaScript Object Utilities
-
+  
+### `deepClone(anObject)`
+Returns a deep clone of a plain Javascript object. The clone, while it has field equal to that of the original object, is separate from the original object.  
+  
 ### `getPaths(anObject)`
 Returns a string array of path/field names inside a JavaScript object.  
+  
 ***Example***  
-```
+```  
 const { getPaths } = require("some-common-functions-js");  
 let client = {  
     name: "Jack",  
@@ -30,12 +36,109 @@ let client = {
 
 let paths = getPaths(client);  
 // ["name", "surname", "address.streetNum", "address.streetName", "address.suburb",  
-//  "address.town", "address.country.name", "address.country.code"]  
-```
+//  "address.town", "address.country.name", "address.country.code"] 
+```  
+  
+### `getSortedObject(anObject)`
+Returns an object with sorted fields, ordered by field name ascending.  
+  
+***Examples***  
+```  
+const { get } = require("common-functions-js");
+const client = {
+    firstName: "Isaiah",
+    lastName: "Tshabalala",
+    address: {
+        houseNum: "5520",
+        streetName: "Main Road",
+        mainPlace: "Evaton",
+        subPlace: "Evaton Small Farms",
+        city: "Vereeniging",
+        country: {
+            name: "South Africa",
+            code: "ZA"
+        }
+    }
+};
+
+const sortedObject = getSortedObject(client);
+/*
+    {
+        address: {
+            city: 'Vereeniging',
+            country: {
+                code: 'ZA',
+                name: 'South Africa'
+            },
+            houseNum: '5520',
+            mainPlace: 'Evaton',
+            streetName: 'Main Road',
+            subPlace: 'Evaton Small Farms'
+        },
+        firstName: 'Isaiah',
+        lastName: 'Tshabalala'
+    }
+*/
+```  
+  
+### `get(anObject, path)`
+Returns the value of an object at the specified path.  
+Can take the place of lodash get() function.
+  
+***Examples***  
+```  
+const { get }  = require("some-common-functions-js");
+const client = {
+    firstName: "Isaiah",
+    lastName: "Tshabalala",
+    address: {
+        houseNum: "5520",
+        streetName: "Main Road",
+        mainPlace: "Evaton",
+        subPlace: "Evaton Small Farms",
+        city: "Vereeniging",
+        country: {
+            name: "South Africa",
+            code: "ZA"
+        }
+    }
+};
+
+let result = get(client, "address.country"); 
+// { name: "South Africa", code: "ZA" }
+
+result = get(client, "address.country.code"); 
+// "ZA"
+```  
+  
+### `set(anObject, path)`
+Sets the value of an object at the specified path.  
+Can take the place of lodash set() function.
+  
+***Examples***   
+```  
+const { set } = require("some-common-functions-js");
+
+let emptyObj = {}; 
+set(emptyObj, "address.country.name", "South Africa");
+set(emptyObj, "address.country.code", "ZA");
+set(emptyObj, "firstName", "Isaiah");
+set(emptyObj, "lastName", "Tshabalala");
+console.log(emptyObj);
+/*
+{
+  address: { country: { name: 'South Africa', code: 'ZA' } },
+  firstName: 'Isaiah',
+  lastName: 'Tshabalala'
+}
+*/
+```  
+  
 ### `hasOnly(anObject, ...fields)`
 Returns `true` if the object contains **only** some or all of the specified fields and no others.  
+  
 ***Examples***  
-```
+```  
 const { hasOnly } = require("some-common-functions-js");  
 
 let car = {  
@@ -54,12 +157,14 @@ result = hasOnly(car, "maxSpeed", "gvm", "power");
 
 result = hasOnly(car, "make", "model");  
 // false, because car has fields other than the specified fields.  
-```
+```  
+  
 ### `hasAll(anObject, ...fields)`
 Returns `true` if the object contains **all** the specified fields.  
 The object may contain additional fields.  
+  
 ***Examples***  
-```
+```  
 const { hasAll } = require("some-common-functions-js");  
 let car = {  
     make: "Ford",  
@@ -73,11 +178,13 @@ let result = hasAll(car, "make", "model");
 
 let result = hasAll(car, "passengerCapacity", "year");  
 // false, because car does not have "passengerCapacity" field.  
-```
+```  
+  
 ### `hasOnlyAll(anObject, ...fields)`
-Return `true` if an object contains only all the specified fields, nothing more, nothing less
-***Example***
-```
+Return `true` if an object contains only all the specified fields, nothing more, nothing less  
+  
+***Examples***  
+```  
 const { hasOnlyAll } = require("some-common-functions-js");  
 let car = {  
     make: "Ford",  
@@ -284,20 +391,16 @@ console.log(objArray);
 */  
 let teams = [  
     {  
-        score: 85,  
-        numGames: 10  
+        score: 85, numGames: 10  
     },  
     {  
-        score: 90,  
-        numGames: 12  
+        score: 90, numGames: 12  
     },  
     {  
-        score: 85,  
-        numGames: 8  
+        score: 85, numGames: 8  
     },  
     {  
-        score: 90,  
-        numGames: 10  
+        score: 90, numGames: 10  
     }  
 ];  
 // Using objCompare to sort fields where there are mixed sort directions.  
@@ -344,7 +447,7 @@ let anIndex = binarySearchObj(teamsArray, searchObj, 0, "score desc", "numGames
 
 let result = objCompare(searchObj, teamsArray[anIndex], "score desc", "numGames asc"); // 0 -- an object with value { score: 85, numGames: 8} exists at teamsArray[anIndex];   
 ```
-## 4. `getObjArrayWithNoDuplicates(objArray, firstOfDuplicates, ...comparisonFields)`
+### `getObjArrayWithNoDuplicates(objArray, firstOfDuplicates, ...comparisonFields)`
 Create an array of objects with duplicates eliminated. Taking only the first or last object from each duplicate set. The input array must be sorted according to the values of comparisonFields.  
  * If firstOfDuplicates === true, then the first element in each set of duplicates is taken.  
  * if firstOfDuplicates === false, then the last element is taken from each set of duplicates.  
@@ -353,7 +456,7 @@ Create an array of objects with duplicates eliminated. Taking only the first or
  * The value of the comparison field must include both the field name and sort direction.  
  * Sort direction assumed to be "asc" if not provided.  
  * Examples of comparison fields: "firstName", "lastName desc", "address.province asc", "address.townOrCity".  
-
+  
 ***Example***  
 ```
 const { getObjArrayWithNoDuplicates } = require("some-common-functions-js");  
@@ -381,8 +484,52 @@ console.log(noDuplicatesArray); // Should contain only unique objects according
         { score: 85, numGames: 10 }  
     ]  
 */  
-```
+```  
+  
+### `getNextDifferent(objArray, targetObj, startFrom, ...comparisonFields)` 
+Get the index in the array of objects, of the next element that is distinct from the target object.  
+Comparison fields must match the field & sort order of the object array.  
+Examples of comparison fields: "firstName", "lastName desc", "address.province asc", "address.townOrCity".  
+  
+***Example***  
+```  
+const { getNextDifferentObj } = require("some-common-functions-js");
+
+teamsArray = [
+    { score: 90, numGames: 10 },
+    { score: 90, numGames: 10 },
+    { score: 90, numGames: 10 },
+    { score: 90, numGames: 12 },
+    { score: 90, numGames: 12 },
+    { score: 90, numGames: 12 },
+    { score: 85, numGames: 8 },
+    { score: 85, numGames: 8 },
+    { score: 85, numGames: 10 },
+    { score: 85, numGames: 10 },
+    { score: 85, numGames: 10 }
+]; // Sorted by "score desc", "numGames asc".
+
+let next = getNextDifferentObj(teamsArray, { score: 85, numGames: 8 }, 0, "score desc", "numGames asc"); 
+// Throws an error because the startFrom index is to the left ('less than') the target object in terms of the field sort order.
+
+next = getNextDifferentObj(teamsArray, { score: 90, numGames: 10 }, 0, "score desc", "numGames asc");
+// 3
+
+
+next = getNextDifferentObj(teamsArray, { score: 85, numGames: 10 }, 0, "score desc", "numGames asc");
+// -1
+```  
+  
+## 4. Date Timestamp Functions
+### `timeStampYyyyMmDd(dateInstance)`
+Converts the date object to a string of the form CCYY-MM-DD 
+
+### `timeStampString(dateInstance)`
+Converts a date object to a string of the form CCYY-MM-DDThh:mm:ss.ccc, e.g. '2024-02-25T15:00:25.251'
+  
+### `addLeadingZeros(aNumber, newLength)`
+Add leading zeros to a numerical string.  E.g. addLeadingZeros(9, 3) = '009'
+  
 ---
 ## License
 MIT
-

package/index.js

@@ -3,9 +3,15 @@
  * Date        Dev   Version  Description
  * 2025/11/19  ITA   1.00     Genesis.
  * 2025/11/28  ITA   1.01     Added function hasOnlyAll().
+ * 2025/12/22  ITA   1.02     Improved documentation of the functions and moved in more functions.
+ * 2025/12/30  ITA   1.03     Removed lodash dependency by re-implementing get() and set() object functions, significantly reducing this package size.
+ *                            Added function getNextDifferent() to deal better with duplicate removal from arrays of objects. *                            .
 */
-const loDash = require('lodash');
 
+/**Return true if userName is valid
+ * @param {string} userName
+ * @returns {boolean} true if a userName is valid, otherwise false.
+ */
 function isValidUserName(userName) {
     if (!userName) // The username must be provided.
         return false;
@@ -15,6 +21,10 @@ function isValidUserName(userName) {
 }
 module.exports.isValidUserName = isValidUserName;
 
+/**Return true if a name is valid
+ * @param {string} name
+ * @returns {boolean} true if a name is valid, otherwise false.
+ */
 function isValidName(name) {
     if (!name) // The name must be provided.
         return false;
@@ -24,6 +34,10 @@ function isValidName(name) {
 }
 module.exports.isValidName = isValidName;
 
+/**Return true if userName is valid
+ * @param {string} email
+ * @returns {boolean} true if an email is valid, otherwise false.
+ */
 function isValidEmail(email) {
     if (!email)
         return false;
@@ -33,6 +47,10 @@ function isValidEmail(email) {
 }
 module.exports.isValidEmail = isValidEmail;
 
+/**Return true if userName is valid
+ * @param {string} num phone number
+ * @returns {boolean} true if phone number is valid, otherwise false.
+ */
 function isValidPhoneNum(num) {
     if (!num) // The number must be provided.
         return false;
@@ -42,6 +60,10 @@ function isValidPhoneNum(num) {
 }
 module.exports.isValidPhoneNum = isValidPhoneNum;
 
+/**Return true if the name of an organisation is valid
+ * @param {string} name an organisation name
+ * @returns {boolean} true if an organisation name is valid, otherwise false.
+ */
 function isValidOrganisationName(name) {  
     if (!name) // The name must be provided.
         return false;
@@ -51,6 +73,10 @@ function isValidOrganisationName(name) {
 }
 module.exports.isValidOrganisationName = isValidOrganisationName;
 
+/**Return true if a password is valid
+ * @param {string} password
+ * @returns {boolean} true if a password is valid, otherwise false.
+ */
 function isValidPassword(password) {
     if (!password)
         return false;
@@ -83,9 +109,79 @@ function isValidPassword(password) {
 }
 module.exports.isValidPassword = isValidPassword;
 
+/** Converts the date object to a string of the form CCYY-MM-DD 
+ * @param {Date} dateObj 
+ * @returns {string} string of the form CCYY-MM-DD
+ */
+function timeStampYyyyMmDd(dateObj) {
+    // Convert the date to string form yyyy-mm-dd
+    let year = dateObj.getFullYear();
+    let month = dateObj.getMonth() + 1;
+    month = addLeadingZeros(month, 2);
+    let day = dateObj.getDate();
+    day = addLeadingZeros(day, 2);
+    return `${year}-${month}-${day}`;
+} // function timeStampYYYYMMDd(dateObj) { 
+module.exports.timeStampYyyyMmDd = timeStampYyyyMmDd;
+
+/** Converts a date object to a string of the form CCYY-MM-DDThh:mm:ss.ccc, e.g. '2024-02-25T15:00:25.251'
+ * @param {Date} dateObj
+ * @returns {string} a string of the form CCYY-MM-DDThh:mm:ss.ccc.
+ */
+function timeStampString(dateObj) {
+    let hours = addLeadingZeros(dateObj.getHours(), 2);
+    let minutes = addLeadingZeros(dateObj.getMinutes(), 2);
+    let seconds = addLeadingZeros(dateObj.getSeconds(), 2);
+    let milliSec = addLeadingZeros(dateObj.getMilliseconds(), 3);
+    return `${timeStampYyyyMmDd(dateObj)}T${hours}:${minutes}:${seconds}.${milliSec}`;
+} // function timeStampString(dateObj) {
+module.exports.timeStampString = timeStampString;
+
+
+/** Return a numeric string with trailing zeros.
+ * E.g. addLeadingZeros(9, 3) = '009'
+ * Inputs: 
+ * @param {Number} aNumber an integer or integer string.
+ * @param {Number} newLength the new length of the resulting string.
+ * @returns a string of a number with the specified number of leading zeros.
+ */
+function addLeadingZeros(aNumber, newLength) {
+  
+    let newString = aNumber + '';
+    const howManyZeros = newLength - newString.length;
+    for (let count = 1; count <= howManyZeros; count++)
+        newString = '0' + newString;
+
+    return newString;
+} // function addLeadingZeros(aString, newLength) {
+module.exports.addLeadingZeros = addLeadingZeros;
+
+/**Convert numeric input to ZAR currency format string. 
+ * @param {Number} a number
+ * @returns a string of the form R 256,534.00
+*/
+function toZarCurrencyFormat(number) {
+    const zarCurrencyFormat = new Intl.NumberFormat('en-US', {style: 'currency', currency: 'ZAR'});
+    return zarCurrencyFormat.format(number).replace(/ZAR/gi, 'R');
+}
+module.exports.toZarCurrencyFormat = toZarCurrencyFormat;
+
+/**Return a deep clone of a document object.
+ * By using deep cloning, you create a new object that is entirely separate from the original original.
+ * So that whatever you do to that clone, such as deletion of fields, does not affect the original.
+ * NB. Class instance types will be converted to plain object types due to stringification.
+ * @param {object} obj a plain Javascript object.
+ * @returns a Javascript object that is separate from the original object.
+ */
+function deepClone(obj) {
+    return JSON.parse(JSON.stringify(obj));
+} // function deepClone(obj) { // Return a deep clone of an object.
+module.exports.deepClone = deepClone;
+
+
 /**
  * Get the paths (fields) of the plain Javascript object.
- * @param {object} anObject 
+ * @param {object} anObject  a plain Javascript object.
  * @returns a sorted string array of paths.
  */
 function getPaths(anObject) {
@@ -108,11 +204,92 @@ function getPaths(anObject) {
 } // function getPaths()
 module.exports.getPaths = getPaths;
 
+/** Return an object with sorted fields,  ordered by field name ascending.
+ * This is desirable when equality comparison is done to ensure two objects sharing equal field values
+ * the pass the equality test stringify(object1) === stringify(object2)
+ * @param {object} pObject 
+ * @returns {object} an object with fields sorted in ascending order of field names.
+*/
+function getSortedObject(pObject) {
+  const objClone = deepClone(pObject);
+  const paths = [];
+  const sortedObject = {};
+
+  // Obtain the outermost fields and sort them.
+  for (let field in objClone) {
+    paths.push(field);
+  }
+  paths.sort();
+
+  // Assign the sorted fields to the new object.
+  for (let index in paths) {
+    const field = paths[index];
+    if (Object.prototype.toString.call(objClone[field]) === '[object Object]') {
+        sortedObject[field] = getSortedObject(objClone[field]);
+    }
+    else {
+        sortedObject[field] = objClone[field];
+    } //
+  } // for (let field in paths) {
+
+  return sortedObject;
+} // function getSortedObject(pObject) {
+module.exports.getSortedObject = getSortedObject;
+
+/** Get the value of a field specified by the path from an object.
+ * @param {object} anObject a Javascript object.
+ * @param {string} path a path specifying the field whose value is to be obtained.
+ * @returns {*} the value of the field specified by the path.
+ */
+function get(anObject, path) {
+    if (getPaths(anObject).includes(path) === false) {
+        console.log(hasAll(anObject, path), path, anObject, getPaths(anObject));
+        throw new Error(`Path ${path} does not exist on the object.`);
+    }
+    let paths = path.split('.');
+    let currentObj = deepClone(anObject);
+
+    let value = currentObj[paths[0]];
+    if (paths.length > 1) {
+        paths.splice(0, 1);
+        return get(value,  paths.join('.'));
+    }
+    else {
+        return value;
+    }
+}
+module.exports.get = get;
+
+/** Set the value of a field specified by the path on an object.
+ * @param {object} anObject a Javascript object.
+ * @param {string} path a path specifying the field whose value is to be set.
+ * @param {*} value the value to set.
+ */
+function set(anObject, path, value) {
+    /*if (hasAll(anObject, path) === false) {
+        throw new Error(`Path ${path} does not exist on the object.`);
+    }*/
+
+    let paths = path.split('.');
+    if (paths.length > 1) {
+        if (!anObject[paths[0]]) {
+            anObject[paths[0]] = {};
+        }
+        const subObject = anObject[paths[0]];
+        paths.splice(0, 1);
+        set(subObject, paths.join('.'), value);
+    }
+    else {
+        anObject[paths[0]] = value;
+    }
+}
+module.exports.set = set;
+
 /**
- * Determine whether an object contains only some or all of the specified fields, and not any other fields.
- * @param {*} anObject a Javascript object.
+ * Determine whether an object contains only 1, some or all of the specified fields, and not any other fields.
+ * @param {object} anObject a Javascript object.
  * @param  {...string} fields one or more field names.
- * @returns boolean.
+ * @returns boolean true or false.
  */
 function hasOnly(anObject, ...fields) {
     if (!fields || !fields.length)
@@ -134,10 +311,10 @@ function hasOnly(anObject, ...fields) {
 module.exports.hasOnly = hasOnly;
 
 /**
- * Determine whether an object contains all of the specified fields. It may have additional fields.
- * @param {*} anObject a Javascript object.
+ * Determine whether an object contains all of the specified fields in addition to other fields.
+ * @param {object} anObject a Javascript object.
  * @param  {...string} fields one or field names.
- * @returns boolean.
+ * @returns boolean true or false.
  */
 function hasAll(anObject, ...fields) {
     if (!fields || !fields.length)
@@ -160,9 +337,9 @@ module.exports.hasAll = hasAll;
 
 /**
  * Determine whether an object contains only all of the specified fields. Nothing more, nothing less.
- * @param {*} anObject a Javascript object.
+ * @param {object} anObject a Javascript object.
  * @param  {...string} fields one or field names.
- * @returns boolean.
+ * @returns boolean true or false.
  */
 function hasOnlyAll(anObject, ...fields) {
     return hasOnly(anObject, ...fields) && hasAll(anObject, ...fields);
@@ -175,6 +352,11 @@ module.exports.hasOnlyAll = hasOnlyAll;
  * otherwise, the index is of closest value in the array that is before or after the search value in terms of sort order.
  * Return -1 for an empty array.
  * This function is to be used also in cases where values are to be inserted into the array while maintaining sort order.
+ * @param {Array} anArray an array of primitve type. All element must be the same type.
+ * @param {*} searchVal search value
+ * @param {number} [startFrom=0] index from which to start. Default: 0.
+ * @param {string} [arraySortDir='asc'] sort direction. Must be 'asc' or 'desc'. Default: 'asc'
+ * @returns {number} an index
  */
 function binarySearch(anArray, searchVal, startFrom = 0, arraySortDir = 'asc') {
 
@@ -212,7 +394,10 @@ module.exports.binarySearch = binarySearch;
  * A return value of -1 means that value1 is before value2 in terms of sort order.
  * A return value of 1 means that value1 is after value2 in terms of sort order.
  * A return value of 0 means that value1 is equal to value2.
- * Sort directions: 'asc', 'desc'. Default is 'asc'.
+ * @param {*} value1
+ * @param {*} value2
+ * @param {string} [sortDir='asc'] 
+ * @returns {number} integer (-1, 0 or 1)
 */
 function compare(value1, value2, sortDir = 'asc') {
     if (!['asc', 'desc'].includes(sortDir))
@@ -236,8 +421,13 @@ module.exports.compare = compare;
  * Return -1 for an empty array.
  * Assumed field data types are Number, String and Date.
  * This function is to be used also in cases where objects are to be inserted into the array while maintaining sort order.
+ * @param {Array<object} objArray an array of Javascript objects.
+ * @param {object} searchObj an object to search for.
+ * @@param {number} [startFrom=0] index from which to start searching.
+ * @param {...string} sortFields one or more search fields.
+ * @returns {number} an index.
  */
-function binarySearchObj(objArray, searchObj, startFrom, ...sortFields) {
+function binarySearchObj(objArray, searchObj, startFrom = 0, ...sortFields) {
     if (objArray.length === 0)
         return -1;
 
@@ -264,7 +454,38 @@ function binarySearchObj(objArray, searchObj, startFrom, ...sortFields) {
 } // function binarySearchObj(objArray, searchObj, ...comparisonFields) {
 module.exports.binarySearchObj = binarySearchObj;
 
-/**Create an array with duplicates eliminated. Taking only the first or last object from each duplicate set.
+/**Get the index of the first element in an object array that is different from the target element 
+ * according to the comparison fields.
+ * @param {Array<object>} objArray an array of objects
+ * @param {object} targetObj target object
+ * @param {number} startFrom index from which to start searching
+ * @param {...string} comparisonFields comparison fields plus sort order.
+ * @returns index of the next different object.
+ */
+function getNextDifferent(objArray, targetObj, startFrom, ...comparisonFields) {
+    let start = startFrom,
+          end = objArray.length - 1;
+
+    // If target object is to the right of objArray[start], then throw an error..
+    if (objCompare(targetObj, objArray[start], ...comparisonFields) > 0) 
+        throw new Error('targetObj is to the right (\'greater than\') objArray[startFrom].');
+         
+    while (start < end) {   
+        let mid = Math.trunc((start + end) / 2);
+        if (objCompare(targetObj, objArray[mid], ...comparisonFields) === 0) {
+            start = mid + 1;
+        }
+        else if (objCompare(targetObj, objArray[mid], ...comparisonFields) < 0) {
+            end = mid;
+        }
+    }
+    if (objCompare(targetObj, objArray[start], ...comparisonFields) === 0)
+        return -1;
+    return start;
+}
+module.exports.getNextDifferent = getNextDifferent;
+
+/**Create an array with duplicates eliminated, according to certain fields. Taking only the first or last object from each duplicate set.
  * If firstOfDuplicates === true, then the first element in each set of duplicates is taken.
  * if firstOfDuplicates === false, then the last element is taken from each set of duplicates.
  * Assumed field data types are Number, String and Date.
@@ -272,91 +493,40 @@ module.exports.binarySearchObj = binarySearchObj;
  * The value of the comparison field must include both the field name and sort direction.
  * Sort direction assumed to be "asc" if not provided.
  * Examples of comparison fields: "firstName", "lastName desc", "address.province asc", "address.townOrCity".
+ * @param {Array<object>} objArray an input array of objects
+ * @param {boolean} firstOfDuplicates specify whether to take the first or last object in each a duplicate set.
+ * @param {...string} comparisonFields comparison fieds plus sort order.
+ * @returns {Array<object>} an array with no duplicates.
  */
 function getObjArrayWithNoDuplicates(objArray, firstOfDuplicates, ...comparisonFields) {
-    function getNextSearchObj(pNext) {
-        const nextObj = {...objArray[next]};
-        let lastField;
-        if (comparisonFields.length > 0)
-            lastField = comparisonFields[comparisonFields.length - 1].split(' ');
-        else
-            throw new Error('Supply atleast 1 comparisonFields parameter.');
-
-        const lastFieldName = lastField[0];
-        const sortDir = lastField.length > 1? lastField[1] : 'asc';
-        const lastFieldValue = loDash.get(nextObj, lastFieldName);
-
-        if (typeof lastFieldValue === 'number') {
-            if (sortDir === 'asc')
-                loDash.set(nextObj, lastFieldName, 1e-10 + lastFieldValue);
-            else
-                loDash.set(nextObj, lastFieldName, -1e-10 + lastFieldValue);
-        }
-        else if (typeof lastFieldValue === 'string') { // instance of String
-            if (sortDir === 'asc')
-                loDash.set(nextObj, lastFieldName, lastFieldValue + ' ');
-            else
-                loDash.set(nextObj, lastFieldName, ' ' + lastFieldValue);
-        }
-        else if (lastFieldValue instanceof Date) {
-            if (sortDir === 'asc')
-                loDash.set(nextObj, lastFieldName, new Date(1 + lastFieldValue.getTime()));
-            else
-                loDash.set(nextObj, lastFieldName, new Date(-1 + lastFieldValue.getTime()));
-        }
-        else
-            throw new Error(`${lastFieldName} must be type Number, String or Date`);
-
-        return nextObj;
-    } // function getNextSearchObj(pNext)
 
     if (objArray.length <= 1)
         return [...objArray];
 
-    if (![true, false].includes(firstOfDuplicates))
-        throw new Error(`firstOfDuplicates must be one of ${[true, false]}`);
+    if (typeof firstOfDuplicates !== 'boolean')
+        throw new Error(`firstOfDuplicates must be boolean true or false.`);
 
     const noDuplicates = [];
-
-    let next = 0;
-    let nextSearchObj;
-    if ((firstOfDuplicates)) {
-        noDuplicates.push(objArray[next]);
-    }        
-    nextSearchObj = getNextSearchObj(objArray[next]);
-
-    while (next < objArray.length) {
-        // The aim is to jump to the next element that is not a duplicate of objArray[next].
-        next = binarySearchObj(objArray, nextSearchObj, next, ...comparisonFields);
-        let comparison = objCompare(objArray[next], nextSearchObj, ...comparisonFields);
-        if (comparison < 0) {
-            if (firstOfDuplicates) {
-                next++;
-                if  (next < objArray.length) {
-                    noDuplicates.push(objArray[next]);
-                    nextSearchObj = getNextSearchObj(objArray[next]);
-                }
-            }
-            else  {
-                noDuplicates.push(objArray[next]);
-                next++;
-                if (next < objArray.length)
-                    nextSearchObj = getNextSearchObj(objArray[next]);
-            }
-            continue;
+    let idx;
+    let grpStart = 0; // Start index of current duplicate group.
+    while (grpStart < objArray.length - 1) {
+        if (firstOfDuplicates) {
+            noDuplicates.push(objArray[grpStart]);
         }
-        else {
-            if (!firstOfDuplicates) {
-                noDuplicates.push(objArray[next]);
-            }
-            else {
-                noDuplicates.push(objArray[next]);
-            }
+
+        grpStart = getNextDifferent(objArray, objArray[grpStart], grpStart + 1, ...comparisonFields);
+        if (grpStart < 0)
+            break; // No more different objects.
+
+        let grpEnd = grpStart - 1;
+        if (!firstOfDuplicates) {
+            noDuplicates.push(objArray[grpEnd]);
         }
-        
-        nextSearchObj = getNextSearchObj(objArray[next]);
-        next++;
-    } // while (comparison !== 0 && next < objArray.length) {
+        idx = grpStart;
+    }
+
+    if (objCompare(objArray[idx], noDuplicates[noDuplicates.length - 1], ...comparisonFields) !== 0)
+        noDuplicates.push(objArray[idx]); // Add the last object.
 
     return noDuplicates;
 } // function getObjArrayWithNoDuplicates(objArray, ...comparisonFields) {
@@ -367,6 +537,9 @@ module.exports.getObjArrayWithNoDuplicates = getObjArrayWithNoDuplicates;
  * Sort directions: 'asc', 'desc'.
  * Examples: 'lastName desc', 'firstName', 'firstName asc', 'address.provinceName asc'.
  * If sort direction is not provided, then it is assumed to be ascending.
+ * @param {object} obj1 first object to compare
+ * @param {object} obj2 second object to compare
+ * @returns {number} a comparison value of 1, 0 or -1
 */
 function objCompare(obj1, obj2, ...comparisonFields) {
     if (comparisonFields.length === 0)
@@ -383,8 +556,8 @@ function objCompare(obj1, obj2, ...comparisonFields) {
         if (!sortDirections.includes(sortDir))
             throw new Error('Sort direction must be one of ' + sortDirections.toString());
 
-        const value1 = loDash.get(obj1, fieldName);
-        const value2 = loDash.get(obj2, fieldName);
+        const value1 = get(obj1, fieldName);
+        const value2 = get(obj2, fieldName);
 
         const returnValue = (sortDir === 'desc'? -1: 1);
         if (value1 > value2)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "some-common-functions-js",
-  "version": "1.0.9",
+  "version": "1.1.2",
   "description": "Common functions used with Javascript objects, and field validation functions.",
   "keywords": [
     "validation",
@@ -36,8 +36,5 @@
   "main": "index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "dependencies": {
-    "lodash": "^4.17.21"
   }
 }