@hkdigital/lib-core 0.3.9 → 0.3.11

package/dist/util/compare/index.js

@@ -1,247 +1,247 @@
-/* ------------------------------------------------------------------ Imports */
-
-import { objectGet } from '../object/index.js';
-
-/* ------------------------------------------------------------------ Exports */
-
-/**
- * Check if the values of two variables should be considered the same
- *
- * @param  {any} value1 - First value for comparison
- * @param  {any} 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 {any} x - First value
- * @param {any} 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 {any} x - First value
- * @param {any} 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 {any} x - First value
- * @param {any} 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 {any} x - First value
- * @param {any} 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 {any} a - First value
- * @param {any} 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 {any} x - First value
- * @param {any} y - Second value
- */
-export function compareUsingKey(compareFn, key, a, b) {
-	// @note assume a and b are objects
-
-	return compareFn(a[key], b[key]);
-}
+/* ------------------------------------------------------------------ Imports */
+
+import { objectGet } from '../object/index.js';
+
+/* ------------------------------------------------------------------ Exports */
+
+/**
+ * Check if the values of two variables should be considered the same
+ *
+ * @param  {any} value1 - First value for comparison
+ * @param  {any} 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 {any} x - First value
+ * @param {any} 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 {any} x - First value
+ * @param {any} 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 {any} x - First value
+ * @param {any} 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 {any} x - First value
+ * @param {any} 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 {any} a - First value
+ * @param {any} 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 {any} x - First value
+ * @param {any} 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/css/css-vars.js

@@ -1,83 +1,83 @@
-let cssVarCache = {};
-
-/**
- * Normalizes a CSS variable name to ensure it has the -- prefix
- *
- * @param {string} varName - The CSS variable name
- * @returns {string} Normalized variable name with -- prefix
- */
-export function normalizeCssVarName(varName) {
-  if (typeof varName !== 'string') {
-    throw new Error('Variable name must be a string');
-  }
-  return varName.startsWith('--') ? varName : `--${varName}`;
-}
-
-/**
- * Extract a CSS variable value from document root
- *
- * @param {string} varName - CSS variable name without '--'
- * @param {boolean} [useCache=false]
- *
- * @returns {any} Parsed value or default
- */
-export function getRootCssVar(varName, useCache = false) {
-  if (cssVarCache[varName] !== undefined && useCache) {
-    return cssVarCache[varName];
-  }
-
-  // Get computed style from document root
-  const rootStyle = getComputedStyle(document.documentElement);
-  const declaration = rootStyle.getPropertyValue(`--${varName}`).trim();
-
-  if (!declaration) {
-    return null;
-  }
-
-  let result;
-
-  // Try to parse as number
-  if (!isNaN(parseFloat(declaration))) {
-    result = parseFloat(declaration);
-  } else {
-    // Return string value
-    result = declaration;
-  }
-
-  // Cache the result
-  cssVarCache[varName] = result;
-  return result;
-}
-
-/**
- * Sets a CSS variable in :root to a new value
- *
- * @param {string} varName - The CSS variable name (with or without --)
- * @param {string|number} value - The new value to set
- * @returns {boolean} True if successful, false otherwise
- */
-export function setRootCssVar(varName, value) {
-  try {
-    if (varName === undefined || varName === null) {
-      throw new Error('Variable name cannot be null or undefined');
-    }
-
-    if (value === undefined || value === null) {
-      throw new Error('Value cannot be null or undefined');
-    }
-
-    const normalizedName = normalizeCssVarName(varName);
-
-    // Convert to string if numeric
-    const formattedValue = typeof value === 'number' ? `${value}` : value;
-
-    document.documentElement.style.setProperty(normalizedName, formattedValue);
-
-    delete cssVarCache[varName];
-
-    return true;
-  } catch (error) {
-    console.error(`Error setting CSS variable ${varName}:`, error);
-    return false;
-  }
-}
+let cssVarCache = {};
+
+/**
+ * Normalizes a CSS variable name to ensure it has the -- prefix
+ *
+ * @param {string} varName - The CSS variable name
+ * @returns {string} Normalized variable name with -- prefix
+ */
+export function normalizeCssVarName(varName) {
+  if (typeof varName !== 'string') {
+    throw new Error('Variable name must be a string');
+  }
+  return varName.startsWith('--') ? varName : `--${varName}`;
+}
+
+/**
+ * Extract a CSS variable value from document root
+ *
+ * @param {string} varName - CSS variable name without '--'
+ * @param {boolean} [useCache=false]
+ *
+ * @returns {any} Parsed value or default
+ */
+export function getRootCssVar(varName, useCache = false) {
+  if (cssVarCache[varName] !== undefined && useCache) {
+    return cssVarCache[varName];
+  }
+
+  // Get computed style from document root
+  const rootStyle = getComputedStyle(document.documentElement);
+  const declaration = rootStyle.getPropertyValue(`--${varName}`).trim();
+
+  if (!declaration) {
+    return null;
+  }
+
+  let result;
+
+  // Try to parse as number
+  if (!isNaN(parseFloat(declaration))) {
+    result = parseFloat(declaration);
+  } else {
+    // Return string value
+    result = declaration;
+  }
+
+  // Cache the result
+  cssVarCache[varName] = result;
+  return result;
+}
+
+/**
+ * Sets a CSS variable in :root to a new value
+ *
+ * @param {string} varName - The CSS variable name (with or without --)
+ * @param {string|number} value - The new value to set
+ * @returns {boolean} True if successful, false otherwise
+ */
+export function setRootCssVar(varName, value) {
+  try {
+    if (varName === undefined || varName === null) {
+      throw new Error('Variable name cannot be null or undefined');
+    }
+
+    if (value === undefined || value === null) {
+      throw new Error('Value cannot be null or undefined');
+    }
+
+    const normalizedName = normalizeCssVarName(varName);
+
+    // Convert to string if numeric
+    const formattedValue = typeof value === 'number' ? `${value}` : value;
+
+    document.documentElement.style.setProperty(normalizedName, formattedValue);
+
+    delete cssVarCache[varName];
+
+    return true;
+  } catch (error) {
+    console.error(`Error setting CSS variable ${varName}:`, error);
+    return false;
+  }
+}

package/dist/util/css/index.js

@@ -1 +1 @@
-export * from './css-vars.js';
+export * from './css-vars.js';

package/dist/util/env/index.js

@@ -1,9 +1,9 @@
-
-export const isTestEnv = (
-  // For Vite environments
-  (typeof import.meta !== 'undefined' && import.meta.env?.MODE === 'test') ||
-  // For Node environments, safely check process
-  (typeof process !== 'undefined' && process?.env?.NODE_ENV === 'test') ||
-  // For Vitest specific check
-  (typeof process !== 'undefined' && process?.env?.VITEST !== undefined)
-);
+
+export const isTestEnv = (
+  // For Vite environments
+  (typeof import.meta !== 'undefined' && import.meta.env?.MODE === 'test') ||
+  // For Node environments, safely check process
+  (typeof process !== 'undefined' && process?.env?.NODE_ENV === 'test') ||
+  // For Vitest specific check
+  (typeof process !== 'undefined' && process?.env?.VITEST !== undefined)
+);