@hkdigital/lib-sveltekit 0.0.41 → 0.0.44

package/dist/util/compare/index.js

@@ -0,0 +1,247 @@
+/* ------------------------------------------------------------------ Imports */
+
+import { objectGet } from '../object/index.js';
+
+/* ------------------------------------------------------------------ Exports */
+
+/**
+ * Check if the values of two variables should be considered the same
+ *
+ * @param  {*} value1 - First value for comparison
+ * @param  {*} value2 - Second value for comparison
+ *
+ * @return {boolean} true if the two values can be considered the same
+ */
+export function equals(value1, value2, _pendingComparisons) {
+	// -- Basic sameness comparisons
+
+	if (typeof value1 !== typeof value2) {
+		// Not the same [type]
+		return false;
+	}
+
+	if (!(value1 instanceof Object) && value1 !== value2) {
+		// [Not an object] and [not the same value]
+		return false;
+	}
+
+	if (value1 === value2) {
+		// [same value or same object reference]
+		return true;
+	}
+
+	if (value1 === null || value2 === null) {
+		// [one of the values is null, the other an object]
+		return false;
+	}
+
+	// -- Check if variables are already being compared
+
+	if (!_pendingComparisons) {
+		_pendingComparisons = { value1: [], value2: [] };
+	} else {
+		const values1 = _pendingComparisons.value1;
+		const values2 = _pendingComparisons.value2;
+
+		if (values1.length > 0) {
+			const foundIndex = values1.indexOf(value1);
+
+			if (-1 !== foundIndex && values2[foundIndex] === value2) {
+				// Objects comparison in progress (it's safe to return true),
+				// since equals will fail on other place if objects differ
+				return true;
+			}
+		}
+	}
+
+	// -- Compare special objects
+
+	switch (value1.constructor) {
+		// Implement other special objects here.
+
+		case RegExp:
+			if (value1.toString() === value2.toString()) {
+				return true;
+			}
+			return false;
+
+		case Date:
+			if (value1.getTime() === value2.getTime()) {
+				return true;
+			}
+			return false;
+	}
+
+	// -- Check if both objects have the same properties
+
+	for (const prop in value1) {
+		if (undefined === value2[prop] && undefined !== value1[prop]) {
+			// (defined) property found in value1 that is undefined in value2
+			return false;
+		}
+	}
+
+	for (const prop in value2) {
+		if (undefined === value1[prop] && undefined !== value2[prop]) {
+			// (defined) property found in value2 that is undefined in value1
+			return false;
+		}
+	}
+
+	// -- Check each property for sameness
+
+	_pendingComparisons.value1.push(value1);
+	_pendingComparisons.value2.push(value2);
+
+	for (const prop in value1) {
+		if (false === equals(value1[prop], value2[prop], _pendingComparisons)) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+// ---------------------------------------------------------------------- Method
+
+/**
+ * Returns true if x is greater than y
+ *
+ * @param {*} x - First value
+ * @param {*} y - Second value
+ */
+export function isGreaterThan(x, y) {
+	if (typeof x === 'undefined') {
+		if (typeof y === 'undefined') {
+			return false;
+		}
+
+		return true;
+	}
+
+	if (typeof y === 'undefined') {
+		return false;
+	}
+
+	return x > y;
+}
+
+// ---------------------------------------------------------------------- Method
+
+/**
+ * Returns true if x is less than y
+ *
+ * @param {*} x - First value
+ * @param {*} y - Second value
+ */
+export function isLessThan(x, y) {
+	if (typeof x === 'undefined') {
+		if (typeof y === 'undefined') {
+			return false;
+		}
+
+		return false;
+	}
+
+	if (typeof y === 'undefined') {
+		return true;
+	}
+
+	return x < y;
+}
+
+// ---------------------------------------------------------------------- Method
+
+/**
+ * Compare function that can be used for sorting smallest values first
+ * - undefined values are placed at the ...???FIXME???... of the sorted array
+ *
+ * @param {*} x - First value
+ * @param {*} y - Second value
+ *
+ * @returns {number} 0 = keep original order,
+ *                   1 = sort x after y,
+ *                  -1 = sort x before y
+ */
+export function smallestFirst(x, y) {
+	if (x === undefined) {
+		if (y === undefined) {
+			return 0;
+		}
+
+		return 1;
+	}
+
+	if (y === undefined) {
+		return -1;
+	}
+
+	return x < y ? -1 : x > y ? 1 : 0;
+}
+
+// ---------------------------------------------------------------------- Method
+
+/**
+ * Compare function that can be used for sorting largest values first
+ * - undefined values are placed at the ...???FIXME???... of the sorted array
+ *
+ * @param {*} x - First value
+ * @param {*} y - Second value
+ *
+ * @returns {number} 0 = keep original order,
+ *                   1 = sort x after y,
+ *                  -1 = sort x before y
+ */
+export function largestFirst(x, y) {
+	if (x === undefined) {
+		if (y === undefined) {
+			return 0;
+		}
+
+		return 1;
+	}
+
+	if (y === undefined) {
+		return -1;
+	}
+
+	return x < y ? 1 : x > y ? -1 : 0;
+}
+
+// ---------------------------------------------------------------------- Method
+
+/**
+ * Comparator that can be used for sorting using an object path
+ *
+ * @param {function} compareFn - Function to use to compare the values
+ *
+ * @param {*} a - First value
+ * @param {*} b - Second value
+ *
+ * @param {string|string[]} path - Object path
+ */
+export function compareUsingPath(compareFn, a, b, path) {
+	// @note assume a and b are objects
+
+	const valueA = objectGet(a, path);
+	const valueB = objectGet(b, path);
+
+	return compareFn(valueA, valueB);
+}
+
+// ---------------------------------------------------------------------- Method
+
+/**
+ * Comparator that can be used for sorting using an object key
+ *
+ * @param {function} compareFn - Function to use to compare the values
+ * @param {string|string[]} path - Object path
+ *
+ * @param {*} x - First value
+ * @param {*} y - Second value
+ */
+export function compareUsingKey(compareFn, key, a, b) {
+	// @note assume a and b are objects
+
+	return compareFn(a[key], b[key]);
+}

package/dist/util/expect/index.d.ts

@@ -1,4 +1,3 @@
-/** Reusable schema's */
 /** Exports */
 /**
  * Throws a validation error if value is not a string
@@ -6,6 +5,24 @@
  * @param {*} value
  */
 export function string(value: any): void;
+/**
+ * Throws a validation error if value is not a boolean
+ *
+ * @param {*} value
+ */
+export function boolean(value: any): void;
+/**
+ * Throws a validation error if value is not a number
+ *
+ * @param {*} value
+ */
+export function number(value: any): void;
+/**
+ * Throws a validation error if value is not a Symbol
+ *
+ * @param {*} value
+ */
+export function symbol(value: any): void;
 /**
  * Throws a validation error if value is not an array of strings
  *
@@ -18,6 +35,36 @@ export function stringArray(value: any): void;
  * @param {*} value
  */
 export function objectArray(value: any): void;
+/**
+ * Throws a validation error if value is not a Promise
+ *
+ * @param {*} value
+ */
+export function promise_(value: any): void;
+/**
+ * Throws a validation error if value is not a Map
+ *
+ * @param {*} value
+ */
+export function map_(value: any): void;
+/**
+ * Throws a validation error if value is not a Set
+ *
+ * @param {*} value
+ */
+export function set_(value: any): void;
+/**
+ * Throws a validation error if value is not an Error instance
+ *
+ * @param {*} value
+ */
+export function error_(value: any): void;
+/**
+ * Expect a value not to be null
+ *
+ * @param {*} value
+ */
+export function notNull(value: any): void;
 /**
  * Expect a value to be a boolean and true
  *
@@ -30,10 +77,74 @@ export function _true(value: any): void;
  * @param {*} value
  */
 export function notEmptyString(value: any): void;
+/**
+ * Throws a validation error if value is not iterable
+ *
+ * @param {*} value
+ */
+export function iterable(value: any): void;
+/**
+ * Throws a validation error if value is not a a store (has not subscribe
+ * method)
+ *
+ * @param {*} value
+ */
+export function store(value: any): void;
+/**
+ * Throws a validation error if value is not array like
+ * - Checks if the value is an object and has a property `length`
+ *
+ * @param {*} value
+ */
+export function arrayLike(value: any): void;
+/**
+ * Throws a validation error if value is not an object or the value
+ * is an array
+ *
+ * @param {*} value
+ */
+export function objectNoArray(value: any): void;
+/**
+ * Throws a validation error if value is not an object or the value
+ * is a function
+ *
+ * @param {*} value
+ */
+export function objectNoFunction(value: any): void;
+/**
+ * Throws a validation error if value is not an object or null
+ *
+ * @param {*} value
+ */
+export function objectOrNull(value: any): void;
+/**
+ * Throws a validation error if value is not an array or Set
+ *
+ * @param {*} value
+ */
+export function arrayOrSet(value: any): void;
+/**
+ * Throws a validation error if value is undefined
+ *
+ * @param {*} value
+ */
+declare function undefined_(value: any): void;
+/**
+ * Throws a validation error if value is not an object
+ *
+ * @param {*} value
+ */
+declare function object_(value: any): void;
+/**
+ * Throws a validation error if value is not an array
+ *
+ * @param {*} value
+ */
+declare function array_(value: any): void;
 /**
  * Throws a validation error if value is not a function
  *
  * @param {*} value
  */
 declare function _function(value: any): void;
-export { _function as function, _function as function, _function as class, _class as class, _true as true, _true as true };
+export { undefined_ as undefined, object_ as object, array_ as array, _function as function, _function as function, _function as class, _class as class, promise_ as promise, map_ as map, set_ as set, error_ as error, _true as true, _true as true };

package/dist/util/expect/index.js

@@ -19,10 +19,7 @@
 
 import * as v from 'valibot';
 
-/** Reusable schema's */
-
-// const StringSchema = v.string();
-// const FunctionSchema = v.function();
+import { isObject } from '../is/index.js';
 
 /** Exports */
 
@@ -34,19 +31,71 @@ import * as v from 'valibot';
  * @param {*} value
  */
 export function string(value) {
-  v.parse(v.string(), value);
+	v.parse(v.string(), value);
+}
+
+/**
+ * Throws a validation error if value is not a boolean
+ *
+ * @param {*} value
+ */
+export function boolean(value) {
+	v.parse(v.boolean(), value);
+}
+
+/**
+ * Throws a validation error if value is not a number
+ *
+ * @param {*} value
+ */
+export function number(value) {
+	v.parse(v.number(), value);
+}
+
+/**
+ * Throws a validation error if value is not a Symbol
+ *
+ * @param {*} value
+ */
+export function symbol(value) {
+	v.parse(v.symbol(), value);
 }
 
-// boolean
-// number
-// symbol
-// defined
+/**
+ * Throws a validation error if value is undefined
+ *
+ * @param {*} value
+ */
+function undefined_(value) {
+	v.parse(v.undefined(), value);
+}
+
+export { undefined_ as undefined };
 
 // > Base objects
 
-// object
+/**
+ * Throws a validation error if value is not an object
+ *
+ * @param {*} value
+ */
+function object_(value) {
+	v.parse(v.custom(isObject), value);
+	// v.parse(v.looseObject({}), value);
+}
 
-// array
+export { object_ as object };
+
+/**
+ * Throws a validation error if value is not an array
+ *
+ * @param {*} value
+ */
+function array_(value) {
+	v.parse(v.instance(Array), value);
+}
+
+export { array_ as array };
 
 /**
  * Throws a validation error if value is not an array of strings
@@ -54,7 +103,7 @@ export function string(value) {
  * @param {*} value
  */
 export function stringArray(value) {
-  v.parse(v.array(v.string()), value);
+	v.parse(v.array(v.string()), value);
 }
 
 /**
@@ -63,7 +112,7 @@ export function stringArray(value) {
  * @param {*} value
  */
 export function objectArray(value) {
-  v.parse(v.array(v.looseObject({})), value);
+	v.parse(v.array(v.looseObject({})), value);
 }
 
 /**
@@ -72,21 +121,67 @@ export function objectArray(value) {
  * @param {*} value
  */
 function _function(value) {
-  v.parse(v.function(), value);
+	v.parse(v.function(), value);
 }
 
 export { _function as function };
 
 export { _function as class };
 
-// promise
-// map
-// set
-// error
+/**
+ * Throws a validation error if value is not a Promise
+ *
+ * @param {*} value
+ */
+export function promise_(value) {
+	v.parse(v.instance(Promise), value);
+}
+
+export { promise_ as promise };
+
+/**
+ * Throws a validation error if value is not a Map
+ *
+ * @param {*} value
+ */
+export function map_(value) {
+	v.parse(v.instance(Map), value);
+}
+
+export { map_ as map };
+
+/**
+ * Throws a validation error if value is not a Set
+ *
+ * @param {*} value
+ */
+export function set_(value) {
+	v.parse(v.instance(Set), value);
+}
+
+export { set_ as set };
+
+/**
+ * Throws a validation error if value is not an Error instance
+ *
+ * @param {*} value
+ */
+export function error_(value) {
+	v.parse(v.instance(Map), value);
+}
+
+export { error_ as error };
 
 // > Common values
 
-// notNull
+/**
+ * Expect a value not to be null
+ *
+ * @param {*} value
+ */
+export function notNull(value) {
+	v.notValue(null, value);
+}
 
 /**
  * Expect a value to be a boolean and true
@@ -94,7 +189,7 @@ export { _function as class };
  * @param {*} value
  */
 export function _true(value) {
-  v.value(true, value);
+	v.value(true, value);
 }
 
 export { _true as true };
@@ -115,31 +210,123 @@ export { _true as true };
  * @param {*} value
  */
 export function notEmptyString(value) {
-  const schema = v.pipe(v.string(), v.minLength(1));
+	const schema = v.pipe(v.string(), v.minLength(1));
 
-  v.parse(schema, value);
+	v.parse(schema, value);
 }
 
 // notEmptyStringOrNull
 
 // asyncIterator
 // iterable
+
+/**
+ * Throws a validation error if value is not iterable
+ *
+ * @param {*} value
+ */
+export function iterable(value) {
+	const schema = v.pipe(v.looseObject({ [Symbol.iterator]: v.function() }));
+
+	v.parse(schema, value);
+}
+
 // iterator
 
-// store
+/**
+ * Throws a validation error if value is not a a store (has not subscribe
+ * method)
+ *
+ * @param {*} value
+ */
+export function store(value) {
+	v.parse(
+		v.custom((value) => {
+			if (!isObject(value) || typeof value.subscribe !== 'function') {
+				return false;
+			}
+
+			return true;
+		}),
+		value
+	);
+}
 
 // notEmptyArray
 // arrayLike
+/**
+ * Throws a validation error if value is not array like
+ * - Checks if the value is an object and has a property `length`
+ *
+ * @param {*} value
+ */
+export function arrayLike(value) {
+	v.parse(v.object({ length: v.number() }), value);
+}
+
 // ArrayBuffer
-// ArrayOfStrings
 // arrayOrUndefined
 // arangoCollectionId
 // uriComponent
-// objectNoArray
-// objectNoFunction
-// objectOrNull
+
+/**
+ * Throws a validation error if value is not an object or the value
+ * is an array
+ *
+ * @param {*} value
+ */
+export function objectNoArray(value) {
+	v.parse(
+		v.custom((value) => {
+			if (!isObject(value) || value instanceof Array) {
+				return false;
+			}
+
+			return true;
+		}),
+		value
+	);
+}
+
+/**
+ * Throws a validation error if value is not an object or the value
+ * is a function
+ *
+ * @param {*} value
+ */
+export function objectNoFunction(value) {
+	v.parse(
+		v.custom((value) => {
+			if (!isObject(value) || typeof value === 'function') {
+				return false;
+			}
+
+			return true;
+		}),
+		value
+	);
+}
+
+/**
+ * Throws a validation error if value is not an object or null
+ *
+ * @param {*} value
+ */
+export function objectOrNull(value) {
+	v.parse(v.union([v.value(null), v.looseObject({})]), value);
+}
+
 // objectOrUndefined
 // objectPath
-// arrayOrSet
+
+/**
+ * Throws a validation error if value is not an array or Set
+ *
+ * @param {*} value
+ */
+export function arrayOrSet(value) {
+	v.parse(v.union([v.instance(Array), v.instance(Set)]), value);
+}
+
 // setOfStrings
 // emptyStringOrSymbol