Merge pull request #16 from adrienv1520/develop

Develop

CHANGELOG.md

@@ -1,5 +1,13 @@
 # CHANGELOG
 
+## 1.2.0 - delivery @11/08/2020
+
+- add math.minmax helper
+- add object.compare helper
+- fix requester
+- add tests
+- update readme
+
 ## 1.1.1 - delivery @18/06/2020
 
 - update project description

README.md

@@ -29,6 +29,8 @@
   - [Encodings](#encodings)
   - [Image](#image)
     - [isPng(buffer)](#ispngbuffer)
+  - [Math](#math)
+    - [minmax(array)](#minmaxarray)
   - [Object](#object)
     - [exists(thing)](#existsthing)
     - [is(Type, thing)](#istype-thing)
@@ -38,6 +40,7 @@
     - [isEmptyOwn(thing)](#isemptyownthing)
     - [getType(thing)](#gettypething)
     - [getTypeName(thing)](#gettypenamething)
+    - [compare(a, b)](#comparea-b)
     - [clone(thing)](#clonething)
   - [Requester](#requester)
     - [requester(options): AsyncFunction](#requesteroptions-asyncfunction)
@@ -323,6 +326,27 @@ Whether a buffer is of png format.
   - `buffer`**<Buffer\>**
   - Returns: **<Boolean\>**
 
+## Math
+
+Math helper.
+
+- `math`**<Object\>** with the following property:
+
+### minmax(array)
+Directly get min and max values in a specific array. Works with numbers or strings.
+  - `array`**<Array\>**<Number|String\>
+  - Returns: **<Object\>**
+      - min: **<Number|String\>**
+      - max: **<Number|String\>**
+
+Examples:
+```javascript
+minmax([55, 9]); // { min: 9, max: 55 }
+minmax(['a', 'b']); // { min: 'a', max: 'b' }
+minmax({}); // {}
+minmax(undefined|null|NaN); // {}
+```
+
 ## Object
 Object helper.
 
@@ -469,6 +493,26 @@ getTypeName(new MyError); // 'MyError'
 getTypeName(undefined|null|NaN); // undefined
 ```
 
+### compare(a, b)
+Compare two numbers or two strings (ignoring case and accents).
+  - `a`**<String|Number\>**
+  - `b`**<String|Number\>**
+  - Returns: **<Object\>**
+      - inferior: **<Boolean\>**
+      - superior: **<Boolean\>**
+      - equal: **<Boolean\>**
+
+Examples:
+```javascript
+compare('a', 'z'); // { inferior: true, superior: false, equal: false }
+compare(55, 9); // { inferior: false, superior: true, equal: false }
+compare(5, 5); // { inferior: false, superior: false, equal: true }
+compare(null); // {}
+compare(undefined); // {}
+compare(NaN, NaN); // {}
+compare(); // {}
+```
+
 ### clone(thing)
 Make a deep copy of a specified object. **Does not handle circular references, use with caution**.
   - `thing`**<Any\>**

lib/index.js

@@ -9,6 +9,7 @@
 const cast = require('./cast');
 const encodings = require('./encodings');
 const image = require('./image');
+const math = require('./math');
 const object = require('./object');
 const requester = require('./requester');
 const string = require('./string');
@@ -19,6 +20,7 @@ module.exports = Object.freeze({
   cast,
   encodings,
   image,
+  math,
   object,
   requester,
   string,

lib/math.js

@@ -0,0 +1,45 @@
+/**
+ * Number helper.
+ *
+ * - minmax(array) -> Object
+ */
+const { is, compare } = require('./object');
+
+/**
+ * @func minmax
+ *
+ * directly get min and max values in a specific array, works with numbers and strings
+ * NOTE: for performance use.
+ *
+ * @param  {Array} array
+ * @return {Object} { min, max }
+ */
+const minmax = function minmax(array) {
+  if (!is(Array, array)) {
+    return { min: undefined, max: undefined };
+  }
+
+  let min;
+  let max;
+
+  array.forEach((value) => {
+    if (max === undefined) {
+      max = value;
+    } else if (compare(value, max).superior) {
+      max = value;
+    }
+
+    if (min === undefined) {
+      min = value;
+    } else if (compare(value, min).inferior) {
+      min = value;
+    }
+  });
+
+  return { min, max };
+};
+
+// exports
+module.exports = Object.freeze({
+  minmax,
+});

lib/object.js

@@ -9,6 +9,7 @@
  *    - isEmptyOwn(thing) -> Boolean
  *    - getType(thing) -> constructor Object
  *    - getTypeName(thing) -> String
+ *    - compare(a, b) -> Object
  *    - clone(thing) -> Object cloned
  */
 
@@ -131,6 +132,35 @@ const getTypeName = function getTypeName(thing) {
   return type !== undefined ? type.name : undefined;
 };
 
+/**
+ * @func compare
+ *
+ * compare two numbers or two strings (ignoring case and accents)
+ * @param  {Number|String} a
+ * @param  {Number|String} b
+ * @return {Object} { inferior, superior, equal }
+ */
+const compare = function compare(a, b) {
+  if (is(Number, a) && is(Number, b)) {
+    return {
+      inferior: a < b,
+      superior: a > b,
+      equal: a === b,
+    };
+  }
+
+  if (is(String, a) && is(String, b)) {
+    const result = a.toLowerCase().localeCompare(b.toLowerCase());
+    return {
+      inferior: result < 0,
+      superior: result > 0,
+      equal: result === 0,
+    };
+  }
+
+  return {};
+};
+
 /**
  * clone
  */
@@ -329,5 +359,6 @@ module.exports = Object.freeze({
   isEmptyOwn,
   getType,
   getTypeName,
+  compare,
   clone,
 });

lib/requester.js

@@ -243,7 +243,7 @@ const requester = function requester(options) {
 
             resolve({ statusCode, headers, body: resBody });
           } catch (e) {
-            const error = new Error(`unable to format response, ${e.message}`);
+            const error = new Error(`unable to format response in ${format}: ${finalBuffer.toString('utf8')}`);
             error.name = 'RequesterError';
             error.code = 'RESPONSE_FORMAT_ERROR';
             return reject(error);