@lowentry/utils 1.19.3 → 1.20.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lowentry/utils",
-  "version": "1.19.3",
+  "version": "1.20.1",
   "private": false,
   "type": "module",
   "main": "./index.js",

package/src/LeUtils.js

@@ -1,6 +1,6 @@
 import FastDeepEqual from 'fast-deep-equal';
 import CloneDeep from 'clone-deep';
-import {ISSET, IS_OBJECT, IS_ARRAY, STRING, INT_LAX, FLOAT_LAX, INT_LAX_ANY, FLOAT_LAX_ANY} from './LeTypes.js';
+import {ISSET, IS_OBJECT, IS_ARRAY, STRING, INT_LAX, FLOAT_LAX, INT_LAX_ANY, FLOAT_LAX_ANY, ARRAY} from './LeTypes.js';
 
 
 /**
@@ -43,7 +43,77 @@ export const LeUtils = {
 	 * @param {*} other The other value to compare.
 	 * @returns {boolean} Returns true if the values are equivalent.
 	 */
-	equals:FastDeepEqual,
+	equals:
+		(value, other) => 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:
+		(() =>
+		{
+			const sortKeyValueArrays = (pairA, pairB) => LeUtils.compare(pairA[0], pairB[0]);
+			return (elementsA, elementsB, ignoreKeys = []) =>
+			{
+				elementsA = LeUtils.mapToArray(elementsA, (value, key) => [key, value]).sort(sortKeyValueArrays);
+				elementsB = LeUtils.mapToArray(elementsB, (value, key) => [key, value]).sort(sortKeyValueArrays);
+				ignoreKeys = (typeof ignoreKeys === 'string') ? ARRAY(ignoreKeys) : LeUtils.mapToArray(ignoreKeys);
+				
+				let indexA = 0;
+				let indexB = 0;
+				while((indexA < elementsA.length) && (indexB < elementsB.length))
+				{
+					const [mapKey, mapValue] = elementsA[indexA];
+					const [ownMapKey, ownMapValue] = elementsB[indexB];
+					
+					const ignoreKeysIncludesMapKey = ignoreKeys.includes(mapKey);
+					const 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.

package/tests/equals.test.js

@@ -0,0 +1,216 @@
+import {describe, test, expect} from 'vitest';
+import {LeUtils, SerializableMap} from '../src/index.js';
+
+
+const KEY_TO_IGNORE = '@ignored@';
+
+const areMapsEqual = (map1, map2) => LeUtils.equalsMapLike(map1, map2);
+const areMapsEqualIgnoreKey = (map1, map2) => LeUtils.equalsMapLike(map1, map2, [KEY_TO_IGNORE]);
+
+
+describe('testing map comparisons', () =>
+{
+	test('map compare true - different classes', () =>
+	{
+		const ownMap = new SerializableMap([['key1', 'value1'], ['key2', 'value2']]);
+		const map = new Map([['key1', 'value1'], ['key2', 'value2']]);
+		expect(areMapsEqual(ownMap, map)).toBe(true);
+	});
+	test('map compare true', () =>
+	{
+		const ownMap = new Map([['key1', 'value1'], ['key2', 'value2']]);
+		const map = new Map([['key1', 'value1'], ['key2', 'value2']]);
+		expect(areMapsEqual(ownMap, map)).toBe(true);
+	});
+	test('map compare false', () =>
+	{
+		const ownMap = new Map([['key1', 'value1'], ['key2', 'value2']]);
+		const map = new Map([['key1', 'value1'], ['key2', 'value3']]);
+		expect(areMapsEqual(ownMap, map)).toBe(false);
+	});
+	test('map compare true - different order', () =>
+	{
+		const ownMap = new Map([['key1', 'value1'], ['key2', 'value2']]);
+		const map = new Map([['key2', 'value2'], ['key1', 'value1']]);
+		expect(areMapsEqual(ownMap, map)).toBe(true);
+	});
+	test('map compare false - different order', () =>
+	{
+		const ownMap = new Map([['key1', 'value1'], ['key2', 'value2']]);
+		const map = new Map([['key2', 'value3'], ['key1', 'value1']]);
+		expect(areMapsEqual(ownMap, map)).toBe(false);
+	});
+	test('map compare true - with location', () =>
+	{
+		const ownMap = new Map([['key1', 'value1'], ['key2', 'value2'], [KEY_TO_IGNORE, '123']]);
+		const map = new Map([['key1', 'value1'], ['key2', 'value2'], [KEY_TO_IGNORE, '123']]);
+		expect(areMapsEqual(ownMap, map)).toBe(true);
+	});
+	test('map compare false - with location', () =>
+	{
+		const ownMap = new Map([['key1', 'value1'], ['key2', 'value2'], [KEY_TO_IGNORE, '123']]);
+		const map = new Map([['key1', 'value1'], ['key2', 'value2'], [KEY_TO_IGNORE, '456']]);
+		expect(areMapsEqual(ownMap, map)).toBe(false);
+	});
+	test('map compare true - ignore location 1', () =>
+	{
+		const ownMap = new Map([['key1', 'value1'], ['key2', 'value2'], [KEY_TO_IGNORE, '123']]);
+		const map = new Map([['key1', 'value1'], ['key2', 'value2']]);
+		expect(areMapsEqualIgnoreKey(ownMap, map)).toBe(true);
+	});
+	test('map compare true - ignore location 2', () =>
+	{
+		const ownMap = new Map([['key1', 'value1'], ['key2', 'value2']]);
+		const map = new Map([['key1', 'value1'], ['key2', 'value2'], [KEY_TO_IGNORE, '123']]);
+		expect(areMapsEqualIgnoreKey(ownMap, map)).toBe(true);
+	});
+	test('map compare false - ignore location 1', () =>
+	{
+		const ownMap = new Map([['key1', 'value1'], ['key2', 'value2'], [KEY_TO_IGNORE, '123']]);
+		const map = new Map([['key1', 'value1'], ['key2', 'value3']]);
+		expect(areMapsEqualIgnoreKey(ownMap, map)).toBe(false);
+	});
+	test('map compare false - ignore location 2', () =>
+	{
+		const ownMap = new Map([['key1', 'value1'], ['key2', 'value2']]);
+		const map = new Map([['key1', 'value1'], ['key2', 'value3'], [KEY_TO_IGNORE, '123']]);
+		expect(areMapsEqualIgnoreKey(ownMap, map)).toBe(false);
+	});
+	test('map compare true - empty map', () =>
+	{
+		const ownMap = new Map();
+		const map = new Map();
+		expect(areMapsEqual(ownMap, map)).toBe(true);
+	});
+	test('map compare false - empty map', () =>
+	{
+		const ownMap = new Map([['key1', 'value1']]);
+		const map = new Map();
+		expect(areMapsEqual(ownMap, map)).toBe(false);
+	});
+	test('map compare true - empty map with location', () =>
+	{
+		const ownMap = new Map([[KEY_TO_IGNORE, '123']]);
+		const map = new Map([[KEY_TO_IGNORE, '123']]);
+		expect(areMapsEqual(ownMap, map)).toBe(true);
+	});
+	test('map compare false - empty map with location', () =>
+	{
+		const ownMap = new Map([[KEY_TO_IGNORE, '123']]);
+		const map = new Map([[KEY_TO_IGNORE, '456']]);
+		expect(areMapsEqual(ownMap, map)).toBe(false);
+	});
+	test('map compare true - empty map ignore location', () =>
+	{
+		const ownMap = new Map([[KEY_TO_IGNORE, '123']]);
+		const map = new Map();
+		expect(areMapsEqualIgnoreKey(ownMap, map)).toBe(true);
+	});
+	test('map compare false - empty map ignore location', () =>
+	{
+		const ownMap = new Map([[KEY_TO_IGNORE, '123']]);
+		const map = new Map([['key1', 'value1']]);
+		expect(areMapsEqualIgnoreKey(ownMap, map)).toBe(false);
+	});
+});
+
+
+describe('testing map-object comparisons', () =>
+{
+	test('map-object compare true', () =>
+	{
+		const ownMap = new Map([['key1', 'value1'], ['key2', 'value2']]);
+		const map = {'key1':'value1', 'key2':'value2'};
+		expect(areMapsEqual(ownMap, map)).toBe(true);
+	});
+	test('map-object compare false', () =>
+	{
+		const ownMap = new Map([['key1', 'value1'], ['key2', 'value2']]);
+		const map = {'key1':'value1', 'key2':'value3'};
+		expect(areMapsEqual(ownMap, map)).toBe(false);
+	});
+	test('map-object compare true - different order', () =>
+	{
+		const ownMap = new Map([['key1', 'value1'], ['key2', 'value2']]);
+		const map = {'key2':'value2', 'key1':'value1'};
+		expect(areMapsEqual(ownMap, map)).toBe(true);
+	});
+	test('map-object compare false - different order', () =>
+	{
+		const ownMap = new Map([['key1', 'value1'], ['key2', 'value2']]);
+		const map = {'key2':'value3', 'key1':'value1'};
+		expect(areMapsEqual(ownMap, map)).toBe(false);
+	});
+	test('map-object compare true - with location', () =>
+	{
+		const ownMap = new Map([['key1', 'value1'], ['key2', 'value2'], [KEY_TO_IGNORE, '123']]);
+		const map = {'key1':'value1', 'key2':'value2', [KEY_TO_IGNORE]:'123'};
+		expect(areMapsEqual(ownMap, map)).toBe(true);
+	});
+	test('map-object compare false - with location', () =>
+	{
+		const ownMap = new Map([['key1', 'value1'], ['key2', 'value2'], [KEY_TO_IGNORE, '123']]);
+		const map = {'key1':'value1', 'key2':'value2', [KEY_TO_IGNORE]:'456'};
+		expect(areMapsEqual(ownMap, map)).toBe(false);
+	});
+	test('map-object compare true - ignore location 1', () =>
+	{
+		const ownMap = new Map([['key1', 'value1'], ['key2', 'value2'], [KEY_TO_IGNORE, '123']]);
+		const map = {'key1':'value1', 'key2':'value2'};
+		expect(areMapsEqualIgnoreKey(ownMap, map)).toBe(true);
+	});
+	test('map-object compare true - ignore location 2', () =>
+	{
+		const ownMap = new Map([['key1', 'value1'], ['key2', 'value2']]);
+		const map = {'key1':'value1', 'key2':'value2', [KEY_TO_IGNORE]:'123'};
+		expect(areMapsEqualIgnoreKey(ownMap, map)).toBe(true);
+	});
+	test('map-object compare false - ignore location 1', () =>
+	{
+		const ownMap = new Map([['key1', 'value1'], ['key2', 'value2'], [KEY_TO_IGNORE, '123']]);
+		const map = {'key1':'value1', 'key2':'value3'};
+		expect(areMapsEqualIgnoreKey(ownMap, map)).toBe(false);
+	});
+	test('map-object compare false - ignore location 2', () =>
+	{
+		const ownMap = new Map([['key1', 'value1'], ['key2', 'value2']]);
+		const map = {'key1':'value1', 'key2':'value3', [KEY_TO_IGNORE]:'123'};
+		expect(areMapsEqualIgnoreKey(ownMap, map)).toBe(false);
+	});
+	test('map-object compare true - empty map', () =>
+	{
+		const ownMap = new Map();
+		const map = {};
+		expect(areMapsEqual(ownMap, map)).toBe(true);
+	});
+	test('map-object compare false - empty map', () =>
+	{
+		const ownMap = new Map([['key1', 'value1']]);
+		const map = {};
+		expect(areMapsEqual(ownMap, map)).toBe(false);
+	});
+	test('map-object compare true - empty map with location', () =>
+	{
+		const ownMap = new Map([[KEY_TO_IGNORE, '123']]);
+		const map = {[KEY_TO_IGNORE]:'123'};
+		expect(areMapsEqual(ownMap, map)).toBe(true);
+	});
+	test('map-object compare false - empty map with location', () =>
+	{
+		const ownMap = new Map([[KEY_TO_IGNORE, '123']]);
+		const map = {[KEY_TO_IGNORE]:'456'};
+		expect(areMapsEqual(ownMap, map)).toBe(false);
+	});
+	test('map-object compare true - empty map ignore location', () =>
+	{
+		const ownMap = new Map([[KEY_TO_IGNORE, '123']]);
+		const map = {};
+		expect(areMapsEqualIgnoreKey(ownMap, map)).toBe(true);
+	});
+	test('map-object compare false - empty map ignore location', () =>
+	{
+		const ownMap = new Map([[KEY_TO_IGNORE, '123']]);
+		const map = {'key1':'value1'};
+		expect(areMapsEqualIgnoreKey(ownMap, map)).toBe(false);
+	});
+});