@lowentry/utils 1.19.4 → 1.20.1

package/build/LeUtils.d.ts

@@ -1,5 +1,6 @@
 export namespace LeUtils {
     function equals(value: any, other: any): boolean;
+    function equalsMapLike(elementsA: any, elementsB: any, ignoreKeys?: any[]): boolean;
     function clone(value: any): any;
     function onDomReady(callback: Function): {
         remove: Function;

package/index.d.ts

@@ -24,6 +24,7 @@ export declare function ISSET(value: any): boolean;
 
 export declare namespace LeUtils {
     export function equals(value: any, other: any): boolean;
+    export function equalsMapLike(elementsA: any, elementsB: any, ignoreKeys?: any[]): boolean;
     export function clone(value: any): any;
     export function onDomReady(callback: Function): {
         remove: Function;

package/index.js

@@ -1,8 +1,8 @@
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _defineProperty from '@babel/runtime/helpers/defineProperty';
 import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
-import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import _typeof from '@babel/runtime/helpers/typeof';
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
 import '@babel/runtime/helpers/awaitAsyncGenerator';
 import _wrapAsyncGenerator from '@babel/runtime/helpers/wrapAsyncGenerator';
 import _regeneratorRuntime from '@babel/runtime/regenerator';
@@ -257,6 +257,68 @@ var LeUtils = {
   equals: function equals(value, other) {
     return FastDeepEqual(value, other);
   },
+  /**
+   * Performs a deep equality comparison between two collections (objects, maps, arrays, etc), sorting on the keys before comparing them.
+   *
+   * This is useful for comparing objects that have the same properties, but in a different order, and/or in a different collection type (like Maps vs Objects).
+   *
+   * @param {*} elementsA The elements to compare.
+   * @param {*} elementsB The other elements to compare.
+   * @param {string[]} [ignoreKeys=[]] An array of keys to ignore when comparing the elements. This is useful for ignoring properties that are not relevant for the comparison.
+   * @return {boolean} Returns true if the given values are equivalent, ignoring the order of properties.
+   */
+  equalsMapLike: function () {
+    var sortKeyValueArrays = function sortKeyValueArrays(pairA, pairB) {
+      return LeUtils.compare(pairA[0], pairB[0]);
+    };
+    return function (elementsA, elementsB) {
+      var ignoreKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+      elementsA = LeUtils.mapToArray(elementsA, function (value, key) {
+        return [key, value];
+      }).sort(sortKeyValueArrays);
+      elementsB = LeUtils.mapToArray(elementsB, function (value, key) {
+        return [key, value];
+      }).sort(sortKeyValueArrays);
+      ignoreKeys = typeof ignoreKeys === 'string' ? ARRAY(ignoreKeys) : LeUtils.mapToArray(ignoreKeys);
+      var indexA = 0;
+      var indexB = 0;
+      while (indexA < elementsA.length && indexB < elementsB.length) {
+        var _elementsA$indexA = _slicedToArray(elementsA[indexA], 2),
+          mapKey = _elementsA$indexA[0],
+          mapValue = _elementsA$indexA[1];
+        var _elementsB$indexB = _slicedToArray(elementsB[indexB], 2),
+          ownMapKey = _elementsB$indexB[0],
+          ownMapValue = _elementsB$indexB[1];
+        var ignoreKeysIncludesMapKey = ignoreKeys.includes(mapKey);
+        var ignoreKeysIncludesOwnMapKey = ignoreKeys.includes(ownMapKey);
+        if (ignoreKeysIncludesMapKey) {
+          indexA++;
+          if (ignoreKeysIncludesOwnMapKey) {
+            indexB++;
+          }
+          continue;
+        } else if (ignoreKeysIncludesOwnMapKey) {
+          indexB++;
+          continue;
+        }
+        if (!LeUtils.equals(mapKey, ownMapKey) || !LeUtils.equals(mapValue, ownMapValue)) {
+          return false;
+        }
+        indexA++;
+        indexB++;
+      }
+      while (indexA < elementsA.length && ignoreKeys.includes(elementsA[indexA][0])) {
+        indexA++;
+      }
+      if (indexA < elementsA.length) {
+        return false;
+      }
+      while (indexB < elementsB.length && ignoreKeys.includes(elementsB[indexB][0])) {
+        indexB++;
+      }
+      return indexB >= elementsB.length;
+    };
+  }(),
   /**
    * Returns a deep copy of the given value.
    *