@lowentry/utils 1.19.4 → 1.21.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lowentry/utils",
-  "version": "1.19.4",
+  "version": "1.21.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';
 
 
 /**
@@ -46,6 +46,75 @@ export const LeUtils = {
 	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.
 	 *
@@ -2919,7 +2988,21 @@ export const LeUtils = {
 	isGivenHostPrivate:
 		(host) =>
 		{
+			host = STRING(host).trim();
+			if(!host)
+			{
+				return false;
+			}
+			try
+			{
+				host = (new URL(host)).hostname;
+			}
+			catch(e)
+			{
+				host = host.split(':')[0];
+			}
 			host = STRING(host).trim().toLowerCase();
+			
 			if((host === 'localhost') || (host === '127.0.0.1'))
 			{
 				return true;
@@ -2934,195 +3017,6 @@ export const LeUtils = {
 				((parts[0] === '192') && (parts[1] === '168')); // 192.168.0.0 - 192.168.255.255
 		},
 	
-	/**
-	 * Creates and returns a new TreeSet.
-	 * A TreeSet is a set of elements, sorted by a comparator.
-	 * Binary search is used to find elements, which makes it very fast to find elements.
-	 *
-	 * The comparator is also used to determine if two values are equal to each other.
-	 * This way, you can have values that aren't the same be treated as if they are. This can be used to deal with issues such as floating point errors for example.
-	 *
-	 * @param {*[]} elements
-	 * @param {(valueA:*, valueB:*) => number} comparator
-	 * @returns {{getElements:(()=>*[]), getComparator:(()=>((valueA:*,valueB:*)=>number)), size:(()=>number), isEmpty:(()=>boolean), contains:((value:*)=>boolean), first:(()=>*|undefined), last:(()=>*|undefined), pollFirst:(()=>*|undefined), pollLast:(()=>*|undefined), add:((value:*)=>void), addAll:((values:*)=>void), getEqualValue:((value:*)=>*), getEqualValueOrAdd:((value:*)=>*)}}
-	 */
-	createTreeSet:
-		(elements, comparator) =>
-		{
-			comparator = comparator || LeUtils.compare;
-			elements = elements || [];
-			elements.sort(comparator);
-			
-			/**
-			 * Performs a binary search on the elements, and returns the result.
-			 *
-			 * @param {*} value
-			 * @returns {{found: boolean,  index: number,  value: *|undefined}}
-			 */
-			const binarySearch = (value) =>
-			{
-				let low = 0;
-				let high = elements.length - 1;
-				while(low <= high)
-				{
-					const mid = Math.floor((low + high) / 2);
-					const midValue = elements[mid];
-					const cmp = comparator(midValue, value);
-					if(cmp < 0)
-					{
-						low = mid + 1;
-					}
-					else if(cmp > 0)
-					{
-						high = mid - 1;
-					}
-					else
-					{
-						return {found:true, index:mid, value:midValue};
-					}
-				}
-				return {found:false, index:low, value:undefined};
-			};
-			
-			const treeSet = {
-				/**
-				 * Returns the elements of the set.
-				 *
-				 * @returns {*[]}
-				 */
-				getElements:
-					() => elements,
-				
-				/**
-				 * Returns the comparator of the set.
-				 *
-				 * @returns {(valueA:*, valueB:*) => number}
-				 */
-				getComparator:
-					() => comparator,
-				
-				/**
-				 * Returns the size of the set.
-				 *
-				 * @returns {number}
-				 */
-				size:
-					() => elements.length,
-				
-				/**
-				 * Returns true if the set is empty, false otherwise.
-				 *
-				 * @returns {boolean}
-				 */
-				isEmpty:
-					() => (elements.length <= 0),
-				
-				/**
-				 * Returns true if the set contains a value that is equal to the given value, returns false otherwise.
-				 *
-				 * @param {*} value
-				 * @returns {boolean}
-				 */
-				contains:
-					(value) => binarySearch(value).found,
-				
-				/**
-				 * Returns the first element of the set, or undefined if it is empty.
-				 *
-				 * @returns {*|undefined}
-				 */
-				first:
-					() => (elements.length > 0) ? elements[0] : undefined,
-				
-				/**
-				 * Returns the last element of the set, or undefined if it is empty.
-				 *
-				 * @returns {*|undefined}
-				 */
-				last:
-					() => (elements.length > 0) ? elements[elements.length - 1] : undefined,
-				
-				/**
-				 * Removes and returns the first element of the set, or undefined if it is empty.
-				 *
-				 * @returns {*|undefined}
-				 */
-				pollFirst:
-					() => (elements.length > 0) ? elements.splice(0, 1)[0] : undefined,
-				
-				/**
-				 * Removes and returns the last element of the set, or undefined if it is empty.
-				 *
-				 * @returns {*|undefined}
-				 */
-				pollLast:
-					() => (elements.length > 0) ? elements.splice(elements.length - 1, 1)[0] : undefined,
-				
-				/**
-				 * Adds the given value to the set. Will only do so if no equal value already exists.
-				 *
-				 * @param {*} value
-				 */
-				add:
-					(value) =>
-					{
-						const result = binarySearch(value);
-						if(result.found)
-						{
-							return;
-						}
-						elements.splice(result.index, 0, value);
-					},
-				
-				/**
-				 * Adds all the given values to the set. Will only do so if no equal value already exists.
-				 *
-				 * @param {*} values
-				 */
-				addAll:
-					(values) =>
-					{
-						LeUtils.each(values, treeSet.add);
-					},
-				
-				/**
-				 * Returns an equal value that's already in the tree set, or undefined if no equal values in it exist.
-				 *
-				 * @param {*} value
-				 * @returns {*|undefined}
-				 */
-				getEqualValue:
-					(value) =>
-					{
-						const result = binarySearch(value);
-						if(result.found)
-						{
-							return result.value;
-						}
-						return undefined;
-					},
-				
-				/**
-				 * Returns an equal value that's already in the tree set. If no equal values in it exist, the given value will be added and returned.
-				 *
-				 * @param {*} value
-				 * @returns {*}
-				 */
-				getEqualValueOrAdd:
-					(value) =>
-					{
-						const result = binarySearch(value);
-						if(result.found)
-						{
-							return result.value;
-						}
-						elements.splice(result.index, 0, value);
-						return value;
-					},
-			};
-			return treeSet;
-		},
-	
 	/**
 	 * @typedef {Object} LeUtils_TransactionalValue
 	 * @property {*} value

package/src/classes/TreeSet.js

@@ -0,0 +1,235 @@
+import {LeUtils} from '../LeUtils.js';
+
+
+/**
+ * A TreeSet is a set of elements, sorted by a comparator.
+ * Binary search is used to find elements, which makes it very fast to find elements.
+ *
+ * The comparator is also used to determine if two values are equal to each other.
+ * This way, you can have values that aren't the same be treated as if they are. This can be used to deal with issues such as floating point errors for example.
+ */
+export class TreeSet
+{
+	/** @type {*[]} */
+	#elements;
+	
+	/** @type {(valueA:*, valueB:*) => number} */
+	#comparator;
+	
+	
+	/**
+	 * Creates a new TreeSet with the given elements and comparator.
+	 *
+	 * @param {*[]} [elements=[]] - The initial elements of the set.
+	 * @param {(valueA:*, valueB:*) => number} [comparator=LeUtils.compare] - The comparator function to use for sorting.
+	 */
+	constructor(elements, comparator)
+	{
+		this.#comparator = comparator || LeUtils.compare;
+		this.#elements = elements || [];
+		this.#elements.sort(this.#comparator);
+	}
+	
+	
+	/**
+	 *
+	 *
+	 * @param {*} value - The value to search for in the set.
+	 * @returns {{found:boolean, index:number, value:*|undefined}} - An object containing whether the value was found, the index where it would be inserted, and the value at that index (if found).
+	 * @private
+	 */
+	binarySearch(value)
+	{
+		let low = 0;
+		let high = this.#elements.length - 1;
+		while(low <= high)
+		{
+			const mid = Math.floor((low + high) / 2);
+			const midValue = this.#elements[mid];
+			const cmp = this.#comparator(midValue, value);
+			if(cmp < 0)
+			{
+				low = mid + 1;
+			}
+			else if(cmp > 0)
+			{
+				high = mid - 1;
+			}
+			else
+			{
+				return {found:true, index:mid, value:midValue};
+			}
+		}
+		return {found:false, index:low, value:undefined};
+	};
+	
+	
+	/**
+	 * Returns the elements of the set.
+	 */
+	getElements()
+	{
+		return this.#elements;
+	}
+	
+	/**
+	 * Returns the comparator of the set.
+	 *
+	 * @returns {(valueA:*, valueB:*) => number}
+	 */
+	getComparator()
+	{
+		return this.#comparator;
+	}
+	
+	/**
+	 * Returns the size of the set.
+	 *
+	 * @returns {number}
+	 */
+	size()
+	{
+		return this.#elements.length;
+	}
+	
+	/**
+	 * Returns true if the set is empty, false otherwise.
+	 *
+	 * @returns {boolean}
+	 */
+	isEmpty()
+	{
+		return (this.#elements.length <= 0);
+	}
+	
+	/**
+	 * Returns true if the set contains a value that is equal to the given value, returns false otherwise.
+	 *
+	 * @param {*} value - The value to check for in the set.
+	 * @return {boolean} - True if the set contains the value, false otherwise.
+	 */
+	contains(value)
+	{
+		return this.binarySearch(value).found;
+	}
+	
+	/**
+	 * Returns the first element of the set, or undefined if it is empty.
+	 *
+	 * @return {*|undefined} - The first element of the set, or undefined if it is empty.
+	 */
+	first()
+	{
+		return (this.#elements.length > 0) ? this.#elements[0] : undefined;
+	}
+	
+	/**
+	 * Returns the last element of the set, or undefined if it is empty.
+	 *
+	 * @return {*|undefined} - The last element of the set, or undefined if it is empty.
+	 */
+	last()
+	{
+		return (this.#elements.length > 0) ? this.#elements[this.#elements.length - 1] : undefined;
+	}
+	
+	/**
+	 * Removes and returns the first element of the set, or undefined if it is empty.
+	 *
+	 * @returns {*|undefined} - The first element of the set, or undefined if it is empty.
+	 */
+	pollFirst()
+	{
+		return (this.#elements.length > 0) ? this.#elements.splice(0, 1)[0] : undefined;
+	}
+	
+	/**
+	 * Removes and returns the last element of the set, or undefined if it is empty.
+	 *
+	 * @returns {*|undefined} - The last element of the set, or undefined if it is empty.
+	 */
+	pollLast()
+	{
+		return (this.#elements.length > 0) ? this.#elements.splice(this.#elements.length - 1, 1)[0] : undefined;
+	}
+	
+	/**
+	 * Adds the given value to the set. Will only do so if no equal value already exists.
+	 * @param {*} value - The value to add to the set.
+	 */
+	add(value)
+	{
+		const result = this.binarySearch(value);
+		if(result.found)
+		{
+			return;
+		}
+		this.#elements.splice(result.index, 0, value);
+	}
+	
+	/**
+	 * Adds all the given values to the set. Will only do so if no equal value already exists.
+	 *
+	 * @param {*} values - The values to add to the set.
+	 */
+	addAll(values)
+	{
+		LeUtils.each(values, this.add.bind(this));
+	}
+	
+	/**
+	 * Returns an equal value that's already in the tree set, or undefined if no equal values in it exist.
+	 *
+	 * @param {*} value - The value to search for in the set.
+	 * @return {*|undefined} - The equal value if found, or undefined if not found.
+	 */
+	getEqualValue(value)
+	{
+		const result = this.binarySearch(value);
+		if(result.found)
+		{
+			return result.value;
+		}
+		return undefined;
+	}
+	
+	/**
+	 * Returns an equal value that's already in the tree set. If no equal values in it exist, the given value will be added and returned.
+	 *
+	 * @param {*} value - The value to search for in the set.
+	 * @return {*} - The equal value if found, or the added value if not found.
+	 */
+	getEqualValueOrAdd(value)
+	{
+		const result = this.binarySearch(value);
+		if(result.found)
+		{
+			return result.value;
+		}
+		this.#elements.splice(result.index, 0, value);
+		return value;
+	}
+	
+	/**
+	 * Returns a string representation of the TreeSet.
+	 *
+	 * @returns {string} - A string representation of the TreeSet, including its elements and comparator.
+	 */
+	toString()
+	{
+		return `TreeSet{elements:${this.#elements}, comparator:${this.#comparator}}`;
+	}
+	
+	/**
+	 * Returns a JSON representation of the TreeSet.
+	 *
+	 * @returns {Object} - An object containing the elements and comparator of the TreeSet.
+	 */
+	toJSON()
+	{
+		return {
+			elements:  this.#elements,
+			comparator:this.#comparator.toString(),
+		};
+	}
+}

package/src/index.js

@@ -2,3 +2,4 @@ export {LeUtils} from './LeUtils.js';
 export {ISSET, IS_ARRAY, ARRAY, IS_OBJECT, OBJECT, STRING, STRING_ANY, INT, INT_ANY, FLOAT, FLOAT_ANY, INT_LAX, INT_LAX_ANY, FLOAT_LAX, FLOAT_LAX_ANY} from './LeTypes.js';
 export {LinkedList} from './classes/LinkedList.js';
 export {SerializableMap} from './classes/SerializableMap.js';
+export {TreeSet} from './classes/TreeSet.js';