@e22m4u/js-repository 0.8.5 → 0.8.7

package/src/utils/get-value-by-path.js

@@ -7,8 +7,12 @@
  * @returns {*}
  */
 export function getValueByPath(obj, path, orElse = undefined) {
-  if (!obj || typeof obj !== 'object') return orElse;
-  if (!path || typeof path !== 'string') return orElse;
+  if (!obj || typeof obj !== 'object') {
+    return orElse;
+  }
+  if (!path || typeof path !== 'string') {
+    return orElse;
+  }
   const keys = path.split('.');
   let value = obj;
   for (const key of keys) {

package/src/utils/is-deep-equal.js

@@ -13,23 +13,33 @@ export function isDeepEqual(firstValue, secondValue) {
     // operator; since the typeof primitive null is object, check
     // if one of the inputs is equal to null. If one of the two
     // inputs is primitive, then I can compare them by reference.
-    if (a === null || b === null) return a === b;
-    if (typeof a !== 'object' || typeof b !== 'object') return a === b;
+    if (a === null || b === null) {
+      return a === b;
+    }
+    if (typeof a !== 'object' || typeof b !== 'object') {
+      return a === b;
+    }
     // Check if the data type of the two inputs are the same,
     // both are arrays or objects. If they are not, return false.
     const dataTypeA = Array.isArray(a) ? 'array' : 'object';
     const dataTypeB = Array.isArray(b) ? 'array' : 'object';
-    if (dataTypeA !== dataTypeB) return false;
+    if (dataTypeA !== dataTypeB) {
+      return false;
+    }
     // Use Object.keys and Object.getOwnPropertySymbols to get
     // all of enumerable and not-inherited properties of the two
     // inputs. Compare their size respectively, if one of them
     // is not equal, return false.
     const keysA = Object.keys(a);
     const keysB = Object.keys(b);
-    if (keysA.length !== keysB.length) return false;
+    if (keysA.length !== keysB.length) {
+      return false;
+    }
     const symbolsA = Object.getOwnPropertySymbols(a);
     const symbolsB = Object.getOwnPropertySymbols(b);
-    if (symbolsA.length !== symbolsB.length) return false;
+    if (symbolsA.length !== symbolsB.length) {
+      return false;
+    }
     // To handle the circular reference, initialize a WeakMap
     // that is going to keep track of the objects or arrays
     // that have been seen, in which each key is an object
@@ -58,10 +68,14 @@ export function isDeepEqual(firstValue, secondValue) {
     // the property value.
     const propertyNamesA = [...keysA, ...symbolsA];
     for (const propertyNameA of propertyNamesA) {
-      if (!Object.prototype.hasOwnProperty.call(b, propertyNameA)) return false;
+      if (!Object.prototype.hasOwnProperty.call(b, propertyNameA)) {
+        return false;
+      }
       const propertyValueA = a[propertyNameA];
       const propertyValueB = b[propertyNameA];
-      if (!compare(propertyValueA, propertyValueB)) return false;
+      if (!compare(propertyValueA, propertyValueB)) {
+        return false;
+      }
     }
     // If we get out of the loop without
     // returning false, return true.

package/src/utils/is-promise.js

@@ -7,7 +7,11 @@
  * @returns {boolean}
  */
 export function isPromise(value) {
-  if (!value) return false;
-  if (typeof value !== 'object') return false;
+  if (!value) {
+    return false;
+  }
+  if (typeof value !== 'object') {
+    return false;
+  }
   return typeof value.then === 'function';
 }

package/src/utils/model-name-to-model-key.js

@@ -7,11 +7,12 @@ import {InvalidArgumentError} from '../errors/index.js';
  * @returns {string}
  */
 export function modelNameToModelKey(modelName) {
-  if (!modelName || typeof modelName !== 'string' || /\s/.test(modelName))
+  if (!modelName || typeof modelName !== 'string' || /\s/.test(modelName)) {
     throw new InvalidArgumentError(
       'The model name should be a non-empty String ' +
         'without spaces, but %v was given.',
       modelName,
     );
+  }
   return modelName.toLowerCase().replace(/[-_]/g, '');
 }

package/src/utils/select-object-keys.js

@@ -8,30 +8,35 @@ import {InvalidArgumentError} from '../errors/index.js';
  * @returns {object}
  */
 export function selectObjectKeys(obj, keys) {
-  if (!obj || typeof obj !== 'object' || Array.isArray(obj))
+  if (!obj || typeof obj !== 'object' || Array.isArray(obj)) {
     throw new InvalidArgumentError(
       'The first argument of selectObjectKeys ' +
         'should be an Object, but %v was given.',
       obj,
     );
-  if (!Array.isArray(keys))
+  }
+  if (!Array.isArray(keys)) {
     throw new InvalidArgumentError(
       'The second argument of selectObjectKeys ' +
         'should be an Array of String, but %v was given.',
       keys,
     );
+  }
   keys.forEach(key => {
-    if (typeof key !== 'string')
+    if (typeof key !== 'string') {
       throw new InvalidArgumentError(
         'The second argument of selectObjectKeys ' +
           'should be an Array of String, but %v was given.',
         key,
       );
+    }
   });
   const result = {};
   const allKeys = Object.keys(obj);
   allKeys.forEach(key => {
-    if (keys.includes(key)) result[key] = obj[key];
+    if (keys.includes(key)) {
+      result[key] = obj[key];
+    }
   });
   return result;
 }

package/src/utils/singularize.js

@@ -5,7 +5,9 @@
  * @returns {string}
  */
 export function singularize(noun) {
-  if (!noun || typeof noun !== 'string') return noun;
+  if (!noun || typeof noun !== 'string') {
+    return noun;
+  }
   const endings = {
     ves: 'fe',
     ies: 'y',