@saber-usa/node-common 1.7.3 → 1.7.4

package/src/utils.js

@@ -1,406 +1,406 @@
-import {cross, dot, norm} from "mathjs";
-
-/**
- * Wrap angle to [0, 2π] range (0 to 360 degrees)
- * @param {number} angleRad - Angle in radians
- * @return {number} Wrapped angle in radians
- */
-function wrapOneRevUnsigned(angleRad) {
-    let wrapped = angleRad % (2 * Math.PI);
-    if (wrapped < 0) {
-        wrapped += 2 * Math.PI;
-    }
-    return wrapped;
-}
-
-/**
- * Wrap angle to [0, π] range (0 to 180 degrees)
- * @param {number} angleRad - Angle in radians
- * @return {number} Wrapped angle in radians
- */
-function wrapHalfRevUnsigned(angleRad) {
-    let wrapped = angleRad % Math.PI;
-    if (wrapped < 0) {
-        wrapped += Math.PI;
-    }
-    return wrapped;
-}
-
-/**
- * Wrap angle to [-π, π] range (-180 to 180 degrees)
- * @param {number} angleRad - Angle in radians
- * @return {number} Wrapped angle in radians
- */
-function wrapHalfRev(angleRad) {
-    let wrapped = angleRad % (2 * Math.PI);
-    if (wrapped > Math.PI) {
-        wrapped -= 2 * Math.PI;
-    } else if (wrapped < -Math.PI) {
-        wrapped += 2 * Math.PI;
-    }
-    return wrapped;
-}
-
-/**
- * Wrap angle to [-π/2, π/2] range (-90 to 90 degrees)
- * @param {number} angleRad - Angle in radians
- * @return {number} Wrapped angle in radians
- */
-function wrapQuarterRev(angleRad) {
-    let wrapped = angleRad % Math.PI;
-    if (wrapped > Math.PI / 2) {
-        wrapped -= Math.PI;
-    } else if (wrapped < -Math.PI / 2) {
-        wrapped += Math.PI;
-    }
-    return wrapped;
-}
-
-/**
-* Will convert a julian date to a gregorian calendar date.
-* @param {Double} julianDay e.g 2460153.253704
-* @return {Date} javascript date object e.g 2023-07-27 18:05:20
-*/
-function julianToGregorian(julianDay) {
-    const j = julianDay + 0.5;
-    const z = Math.floor(j);
-    const f = j - z - 0.5; // subtract 0.5 to account for the day starting at noon
-    const dayFraction = f + 0.5; // add 0.5 to account for the day starting at midnight
-
-    let a;
-
-    if (z < 2299161) {
-        a = z;
-    } else {
-        const alpha = Math.floor((z - 1867216.25) / 36524.25);
-        a = z + 1 + alpha - Math.floor(alpha / 4);
-    }
-
-    const b = a + 1524;
-    const c = Math.floor((b - 122.1) / 365.25);
-    const d = Math.floor(365.25 * c);
-    const e = Math.floor((b - d) / 30.6001);
-
-    const day = b - d - Math.floor(30.6001 * e);
-    const month = e < 14 ? e - 1 : e - 13;
-    const year = month > 2 ? c - 4716 : c - 4715;
-
-    // Calculate hours, minutes, and seconds
-    const hour = Math.floor(dayFraction * 24);
-    const minute = Math.floor((dayFraction * 24 - hour) * 60);
-    const second = Math.floor(((dayFraction * 24 - hour) * 60 - minute) * 60);
-
-    const ms = Math.floor((((dayFraction * 24 - hour) * 60 - minute) * 60 - second)*1000);
-
-    return new Date(Date.UTC(year, month - 1, day, hour, minute, second, ms));
-}
-
-/**
- * Converts an epoch (days and year) to a date string
- * @param {Number} days, number of days since the beginning of the year
- * @param {Number} year, the year
- * @return {String} a date string in the format YYYY-MM-DDTHH:MM:SSZ
- */
-function epochToDate(days, year) {
-    const millisecondsPerDay = 24 * 60 * 60 * 1000; // Number of milliseconds in a day
-
-    // Create a Date object representing January 1st of the given year, in UTC
-    const startDate = new Date(Date.UTC(year, 0, 1));
-
-    // Calculate the total milliseconds from the start of the year
-    const totalMilliseconds = startDate.getTime() + (days - 1) * millisecondsPerDay;
-
-    // Create a new Date object using the total milliseconds, ensuring it's treated as UTC
-    const date = new Date(totalMilliseconds);
-
-    // Extract the individual components from the Date object, all in UTC
-    const yearString = date.getUTCFullYear().toString().padStart(4, "0");
-    const monthString = (date.getUTCMonth() + 1).toString().padStart(2, "0");
-    const dayString = date.getUTCDate().toString().padStart(2, "0");
-    const hoursString = date.getUTCHours().toString().padStart(2, "0");
-    const minutesString = date.getUTCMinutes().toString().padStart(2, "0");
-    const secondsString = date.getUTCSeconds().toString().padStart(2, "0");
-
-    // Construct the date string in the desired format
-    const dateString = `${yearString}-${monthString}-${dayString}T${hoursString}:${minutesString}:${secondsString}Z`;
-
-    return dateString;
-}
-
-/**
- * Calculates the magnitude given a vector object
- *
- * @param {Object} v Expects a vector object: v{x,y,z}
- *
- * @return {Object} Returns magnitude object
- */
-const getMagnitude = function(v) {
-    return Math.sqrt((v.x * v.x) + (v.y * v.y) + (v.z * v.z));
-};
-
-/**
- * The code normalizes the values of a vector by dividing them by their magnitude
- *
- * @param {Object} v Expects a vector object: v{x,y,z}
- *
- * @return {Object} Returns normalized vector v{x,y,z}
- */
-const normalize = (v) => {
-    const mag = getMagnitude(v);
-    return {
-        x: v.x / mag,
-        y: v.y / mag,
-        z: v.z / mag,
-    };
-};
-
-/**
- * [
-    [1,2,3],
-    [1,2,3],
-    [1,2,3],
-   ]
-   Converts to:
-   [
-    [1,1,1],
-    [2,2,2],
-    [3,3,3],
-   ]
- * @param {*} Array2D
-
- * @return {array} The transposed array
- */
-const transpose = (Array2D) => {
-    return Array2D[0].map((_, colIndex) => Array2D.map((row) => row[colIndex]));
-};
-
-/**
- * Multiply a Vector by a Rotation Matrix and calculate a final 3D vector
- *
- * @param {Object} vector Vector object with x, y, z properties
- * @param {Array} matrix Rotation Matrix
- *
- * @return {Object} Final 3D vector
- */
-const multiplyVector = (vector, matrix) => {
-    const X = matrix[0][0] * vector.x
-        + matrix[0][1] * vector.y
-        + matrix[0][2] * vector.z;
-
-    const Y = matrix[1][0] * vector.x
-        + matrix[1][1] * vector.y
-        + matrix[1][2] * vector.z;
-
-    const Z = matrix[2][0] * vector.x
-        + matrix[2][1] * vector.y
-        + matrix[2][2] * vector.z;
-
-    return {
-        x: X,
-        y: Y,
-        z: Z,
-    };
-};
-
-/**
- * Calculates the distance between two points
- *
- * @param {Object} p1 {x,y,z} coordinates
- * @param {Object} p2 {x,y,z} coordinates
- *
- * @return {Number} Distance between the two points
- */
-const dist = (p1, p2) => {
-    const a = p2.x - p1.x;
-    const b = p2.y - p1.y;
-    const c = p2.z - p1.z;
-    return Math.sqrt(a * a + b * b + c * c);
-};
-
-/** Checks if the variable is a valid dataMode string.
- *
- * @param {String} dataMode The dataMode to evaluate
- * @return {Boolean} True if input is a valid dataMode, false otherwise
- */
-const isValidDataMode = (dataMode) => {
-    const validDataModes = ["REAL", "EXERCISE", "TEST", "SIMULATED"];
-    if (isNonEmptyString(dataMode)) {
-        return validDataModes.includes(dataMode);
-    }
-    return false;
-};
-
-/** Check if a variable is of boolean type
- *
- * @param {*} variable The variable to be tested
- * @return {Boolean} True is the variable is boolean, false otherwise
- */
-const isBoolean = (variable) => {
-    return typeof variable === "boolean";
-};
-
-/** Check if a variable is a valid AND non-empty string.
- *
- * @param {*} variable The variable to test
- * @return {Boolean} True if it is valid and non-empty string, false otherwise.
- */
-const isNonEmptyString = (variable) => {
-    return typeof variable === "string" && variable.trim() !== "";
-};
-
-/** A function that removes object properties that are null or undefined.
- * It is not recursive, it only removes first level properties and not nested objects.
- * It is ES6 compatible.
- * https://stackoverflow.com/questions/286141/remove-blank-attributes-from-an-object-in-javascript
- *
- * @param {Object} obj The object to clean up from null and undefined properties.
- * @return {Object} The mutated object with null and undefined properties removed.
- */
-const removeNullUndefined = (obj) => {
-    Object.keys(obj).forEach((k) => obj[k] === null && delete obj[k]);
-    return obj;
-};
-
-const getTimeDifference = (datetimeString)=>{
-    // Parse the provided datetime string to a Date object
-    const providedDate = new Date(datetimeString).getTime();
-
-    // Get the current UTC date and time
-    const currentUTCDate = Date.now(); // use Date.now() for jest mock
-
-    // Calculate the time difference in milliseconds
-    const timeDifferenceInMilliseconds = (providedDate > currentUTCDate)
-        ? providedDate - currentUTCDate
-        : currentUTCDate - providedDate;
-
-    // Calculate the time difference in hours, minutes, and seconds
-    let timeDifferenceInSeconds = Math.floor(timeDifferenceInMilliseconds / 1000);
-    const hours = Math.floor(timeDifferenceInSeconds / 3600);
-    timeDifferenceInSeconds %= 3600;
-    const minutes = Math.floor(timeDifferenceInSeconds / 60);
-    const seconds = timeDifferenceInSeconds % 60;
-
-    // Return the time difference
-    return ((hours > 0) ? hours + "h " : "")
-        + ((minutes >0) ? minutes + "m " : "")
-        + seconds+"s";
-};
-
-/** A function that properly checks if a variable is defined.
- *
- * @param {Object} v The variable to check
- * @return {Boolean} true if the number is even, false otherwise.
-*/
-const isDefined = (v) => {
-    return v!== undefined && v!== null;
-};
-
-/** Compute the angular separation between two vectors.
- *
- * This method computes the angular separation between two vectors using the dot product
- * for well separated vectors and the cross product for almost aligned vectors.
- * This allows to have a good accuracy in all cases, even for vectors very close to each other.
- *
- * The function is a JavaScript adaptation of Java Hipparchus Math library function Vector3D.angle(...),
- * which is frequently used in all of Orekit.
- * @param {Array} v1 First vector
- * @param {Array} v2 Second vector
- * @return {Number} The angle between the two vectors, in radians
- */
-const getAngle = (v1, v2) => {
-    const normProduct = norm(v1) * norm(v2);
-    if (normProduct === 0) {
-        throw new Error("One of the two vectors has zero norm!");
-    }
-
-    const dotPr = dot(v1, v2);
-    const threshold = normProduct * 0.9999;
-    if ((dotPr < -threshold) || (dotPr > threshold)) {
-        // the vectors are almost aligned, compute using the sine
-        const v3 = cross(v1, v2);
-        if (dotPr >= 0) {
-            return Math.asin(norm(v3) / normProduct);
-        }
-        return Math.PI - Math.asin(norm(v3) / normProduct);
-    }
-    // the vectors are sufficiently separated to use the cosine
-    return Math.acos(dotPr / normProduct);
-};
-
-/**
- * Wraps a number to the specified range [min, max).
- * @param {number} value - The number to wrap.
- * @param {number} min - The minimum value of the range.
- * @param {number} max - The maximum value of the range (exclusive).
- * @return {number} The wrapped number within the specified range.
- */
-const wrapToRange = (value, min, max) => {
-    const range = max - min;
-    return ((((value - min) % range) + range) % range) + min;
-};
-
-/**
- * Converts XYZ position object to array
- * @param {Object} pos - Position object with x, y, and z values
- * @return {Array} position array [x, y, z]
- */
-const posToArray = (pos) => {
-    return [pos.x, pos.y, pos.z];
-};
-
-/** Returns the CW signed minimum difference between two angles on a ciscular buffer of 0 to 360.
- *
- * This function is commonly used to correctly compute longitude or azimuth differences.
- *
- * A positive value means that the minimum angle formed from the initial to the final position is CW.
- * A negative value means that the minimum angle formed from the initial to the final position is CCW.
- *
- * @example
- * // returns 20
- * getAngleDiffSigned(350, 10);
- * @example
- * // returns -20
- * globalNS.method(10, 350);
- *
- * @param {Number} initial The initial angle value in 0 to 360
- * @param {Number} final The final angle value in 0 to 360
- * @return {Number} The clock-wise signed minimum angle difference
- */
-const getAngleDiffSigned = (initial, final) => {
-    const diff = final - initial;
-    const angle = Math.abs(diff);
-    const minAngle = Math.min(angle, 360 - angle);
-    let sign;
-
-    if (angle <= 180) {
-        sign = diff >= 0 ? 1 : -1;
-    } else {
-        sign = (diff - 360 * Math.sign(diff)) >= 0 ? 1 : -1;
-    }
-
-    return sign * minAngle;
-};
-
-export {
-    wrapOneRevUnsigned,
-    wrapHalfRevUnsigned,
-    wrapHalfRev,
-    wrapQuarterRev,
-    julianToGregorian,
-    epochToDate,
-    getMagnitude,
-    normalize,
-    transpose,
-    multiplyVector,
-    dist,
-    isValidDataMode,
-    isBoolean,
-    isNonEmptyString,
-    removeNullUndefined,
-    getTimeDifference,
-    isDefined,
-    wrapToRange,
-    getAngle,
-    getAngleDiffSigned,
-    posToArray,
-};
+import {cross, dot, norm} from "mathjs";
+
+/**
+ * Wrap angle to [0, 2π] range (0 to 360 degrees)
+ * @param {number} angleRad - Angle in radians
+ * @return {number} Wrapped angle in radians
+ */
+function wrapOneRevUnsigned(angleRad) {
+    let wrapped = angleRad % (2 * Math.PI);
+    if (wrapped < 0) {
+        wrapped += 2 * Math.PI;
+    }
+    return wrapped;
+}
+
+/**
+ * Wrap angle to [0, π] range (0 to 180 degrees)
+ * @param {number} angleRad - Angle in radians
+ * @return {number} Wrapped angle in radians
+ */
+function wrapHalfRevUnsigned(angleRad) {
+    let wrapped = angleRad % Math.PI;
+    if (wrapped < 0) {
+        wrapped += Math.PI;
+    }
+    return wrapped;
+}
+
+/**
+ * Wrap angle to [-π, π] range (-180 to 180 degrees)
+ * @param {number} angleRad - Angle in radians
+ * @return {number} Wrapped angle in radians
+ */
+function wrapHalfRev(angleRad) {
+    let wrapped = angleRad % (2 * Math.PI);
+    if (wrapped > Math.PI) {
+        wrapped -= 2 * Math.PI;
+    } else if (wrapped < -Math.PI) {
+        wrapped += 2 * Math.PI;
+    }
+    return wrapped;
+}
+
+/**
+ * Wrap angle to [-π/2, π/2] range (-90 to 90 degrees)
+ * @param {number} angleRad - Angle in radians
+ * @return {number} Wrapped angle in radians
+ */
+function wrapQuarterRev(angleRad) {
+    let wrapped = angleRad % Math.PI;
+    if (wrapped > Math.PI / 2) {
+        wrapped -= Math.PI;
+    } else if (wrapped < -Math.PI / 2) {
+        wrapped += Math.PI;
+    }
+    return wrapped;
+}
+
+/**
+* Will convert a julian date to a gregorian calendar date.
+* @param {Double} julianDay e.g 2460153.253704
+* @return {Date} javascript date object e.g 2023-07-27 18:05:20
+*/
+function julianToGregorian(julianDay) {
+    const j = julianDay + 0.5;
+    const z = Math.floor(j);
+    const f = j - z - 0.5; // subtract 0.5 to account for the day starting at noon
+    const dayFraction = f + 0.5; // add 0.5 to account for the day starting at midnight
+
+    let a;
+
+    if (z < 2299161) {
+        a = z;
+    } else {
+        const alpha = Math.floor((z - 1867216.25) / 36524.25);
+        a = z + 1 + alpha - Math.floor(alpha / 4);
+    }
+
+    const b = a + 1524;
+    const c = Math.floor((b - 122.1) / 365.25);
+    const d = Math.floor(365.25 * c);
+    const e = Math.floor((b - d) / 30.6001);
+
+    const day = b - d - Math.floor(30.6001 * e);
+    const month = e < 14 ? e - 1 : e - 13;
+    const year = month > 2 ? c - 4716 : c - 4715;
+
+    // Calculate hours, minutes, and seconds
+    const hour = Math.floor(dayFraction * 24);
+    const minute = Math.floor((dayFraction * 24 - hour) * 60);
+    const second = Math.floor(((dayFraction * 24 - hour) * 60 - minute) * 60);
+
+    const ms = Math.floor((((dayFraction * 24 - hour) * 60 - minute) * 60 - second)*1000);
+
+    return new Date(Date.UTC(year, month - 1, day, hour, minute, second, ms));
+}
+
+/**
+ * Converts an epoch (days and year) to a date string
+ * @param {Number} days, number of days since the beginning of the year
+ * @param {Number} year, the year
+ * @return {String} a date string in the format YYYY-MM-DDTHH:MM:SSZ
+ */
+function epochToDate(days, year) {
+    const millisecondsPerDay = 24 * 60 * 60 * 1000; // Number of milliseconds in a day
+
+    // Create a Date object representing January 1st of the given year, in UTC
+    const startDate = new Date(Date.UTC(year, 0, 1));
+
+    // Calculate the total milliseconds from the start of the year
+    const totalMilliseconds = startDate.getTime() + (days - 1) * millisecondsPerDay;
+
+    // Create a new Date object using the total milliseconds, ensuring it's treated as UTC
+    const date = new Date(totalMilliseconds);
+
+    // Extract the individual components from the Date object, all in UTC
+    const yearString = date.getUTCFullYear().toString().padStart(4, "0");
+    const monthString = (date.getUTCMonth() + 1).toString().padStart(2, "0");
+    const dayString = date.getUTCDate().toString().padStart(2, "0");
+    const hoursString = date.getUTCHours().toString().padStart(2, "0");
+    const minutesString = date.getUTCMinutes().toString().padStart(2, "0");
+    const secondsString = date.getUTCSeconds().toString().padStart(2, "0");
+
+    // Construct the date string in the desired format
+    const dateString = `${yearString}-${monthString}-${dayString}T${hoursString}:${minutesString}:${secondsString}Z`;
+
+    return dateString;
+}
+
+/**
+ * Calculates the magnitude given a vector object
+ *
+ * @param {Object} v Expects a vector object: v{x,y,z}
+ *
+ * @return {Object} Returns magnitude object
+ */
+const getMagnitude = function(v) {
+    return Math.sqrt((v.x * v.x) + (v.y * v.y) + (v.z * v.z));
+};
+
+/**
+ * The code normalizes the values of a vector by dividing them by their magnitude
+ *
+ * @param {Object} v Expects a vector object: v{x,y,z}
+ *
+ * @return {Object} Returns normalized vector v{x,y,z}
+ */
+const normalize = (v) => {
+    const mag = getMagnitude(v);
+    return {
+        x: v.x / mag,
+        y: v.y / mag,
+        z: v.z / mag,
+    };
+};
+
+/**
+ * [
+    [1,2,3],
+    [1,2,3],
+    [1,2,3],
+   ]
+   Converts to:
+   [
+    [1,1,1],
+    [2,2,2],
+    [3,3,3],
+   ]
+ * @param {*} Array2D
+
+ * @return {array} The transposed array
+ */
+const transpose = (Array2D) => {
+    return Array2D[0].map((_, colIndex) => Array2D.map((row) => row[colIndex]));
+};
+
+/**
+ * Multiply a Vector by a Rotation Matrix and calculate a final 3D vector
+ *
+ * @param {Object} vector Vector object with x, y, z properties
+ * @param {Array} matrix Rotation Matrix
+ *
+ * @return {Object} Final 3D vector
+ */
+const multiplyVector = (vector, matrix) => {
+    const X = matrix[0][0] * vector.x
+        + matrix[0][1] * vector.y
+        + matrix[0][2] * vector.z;
+
+    const Y = matrix[1][0] * vector.x
+        + matrix[1][1] * vector.y
+        + matrix[1][2] * vector.z;
+
+    const Z = matrix[2][0] * vector.x
+        + matrix[2][1] * vector.y
+        + matrix[2][2] * vector.z;
+
+    return {
+        x: X,
+        y: Y,
+        z: Z,
+    };
+};
+
+/**
+ * Calculates the distance between two points
+ *
+ * @param {Object} p1 {x,y,z} coordinates
+ * @param {Object} p2 {x,y,z} coordinates
+ *
+ * @return {Number} Distance between the two points
+ */
+const dist = (p1, p2) => {
+    const a = p2.x - p1.x;
+    const b = p2.y - p1.y;
+    const c = p2.z - p1.z;
+    return Math.sqrt(a * a + b * b + c * c);
+};
+
+/** Checks if the variable is a valid dataMode string.
+ *
+ * @param {String} dataMode The dataMode to evaluate
+ * @return {Boolean} True if input is a valid dataMode, false otherwise
+ */
+const isValidDataMode = (dataMode) => {
+    const validDataModes = ["REAL", "EXERCISE", "TEST", "SIMULATED"];
+    if (isNonEmptyString(dataMode)) {
+        return validDataModes.includes(dataMode);
+    }
+    return false;
+};
+
+/** Check if a variable is of boolean type
+ *
+ * @param {*} variable The variable to be tested
+ * @return {Boolean} True is the variable is boolean, false otherwise
+ */
+const isBoolean = (variable) => {
+    return typeof variable === "boolean";
+};
+
+/** Check if a variable is a valid AND non-empty string.
+ *
+ * @param {*} variable The variable to test
+ * @return {Boolean} True if it is valid and non-empty string, false otherwise.
+ */
+const isNonEmptyString = (variable) => {
+    return typeof variable === "string" && variable.trim() !== "";
+};
+
+/** A function that removes object properties that are null or undefined.
+ * It is not recursive, it only removes first level properties and not nested objects.
+ * It is ES6 compatible.
+ * https://stackoverflow.com/questions/286141/remove-blank-attributes-from-an-object-in-javascript
+ *
+ * @param {Object} obj The object to clean up from null and undefined properties.
+ * @return {Object} The mutated object with null and undefined properties removed.
+ */
+const removeNullUndefined = (obj) => {
+    Object.keys(obj).forEach((k) => obj[k] === null && delete obj[k]);
+    return obj;
+};
+
+const getTimeDifference = (datetimeString)=>{
+    // Parse the provided datetime string to a Date object
+    const providedDate = new Date(datetimeString).getTime();
+
+    // Get the current UTC date and time
+    const currentUTCDate = Date.now(); // use Date.now() for jest mock
+
+    // Calculate the time difference in milliseconds
+    const timeDifferenceInMilliseconds = (providedDate > currentUTCDate)
+        ? providedDate - currentUTCDate
+        : currentUTCDate - providedDate;
+
+    // Calculate the time difference in hours, minutes, and seconds
+    let timeDifferenceInSeconds = Math.floor(timeDifferenceInMilliseconds / 1000);
+    const hours = Math.floor(timeDifferenceInSeconds / 3600);
+    timeDifferenceInSeconds %= 3600;
+    const minutes = Math.floor(timeDifferenceInSeconds / 60);
+    const seconds = timeDifferenceInSeconds % 60;
+
+    // Return the time difference
+    return ((hours > 0) ? hours + "h " : "")
+        + ((minutes >0) ? minutes + "m " : "")
+        + seconds+"s";
+};
+
+/** A function that properly checks if a variable is defined.
+ *
+ * @param {Object} v The variable to check
+ * @return {Boolean} true if the number is even, false otherwise.
+*/
+const isDefined = (v) => {
+    return v!== undefined && v!== null;
+};
+
+/** Compute the angular separation between two vectors.
+ *
+ * This method computes the angular separation between two vectors using the dot product
+ * for well separated vectors and the cross product for almost aligned vectors.
+ * This allows to have a good accuracy in all cases, even for vectors very close to each other.
+ *
+ * The function is a JavaScript adaptation of Java Hipparchus Math library function Vector3D.angle(...),
+ * which is frequently used in all of Orekit.
+ * @param {Array} v1 First vector
+ * @param {Array} v2 Second vector
+ * @return {Number} The angle between the two vectors, in radians
+ */
+const getAngle = (v1, v2) => {
+    const normProduct = norm(v1) * norm(v2);
+    if (normProduct === 0) {
+        throw new Error("One of the two vectors has zero norm!");
+    }
+
+    const dotPr = dot(v1, v2);
+    const threshold = normProduct * 0.9999;
+    if ((dotPr < -threshold) || (dotPr > threshold)) {
+        // the vectors are almost aligned, compute using the sine
+        const v3 = cross(v1, v2);
+        if (dotPr >= 0) {
+            return Math.asin(norm(v3) / normProduct);
+        }
+        return Math.PI - Math.asin(norm(v3) / normProduct);
+    }
+    // the vectors are sufficiently separated to use the cosine
+    return Math.acos(dotPr / normProduct);
+};
+
+/**
+ * Wraps a number to the specified range [min, max).
+ * @param {number} value - The number to wrap.
+ * @param {number} min - The minimum value of the range.
+ * @param {number} max - The maximum value of the range (exclusive).
+ * @return {number} The wrapped number within the specified range.
+ */
+const wrapToRange = (value, min, max) => {
+    const range = max - min;
+    return ((((value - min) % range) + range) % range) + min;
+};
+
+/**
+ * Converts XYZ position object to array
+ * @param {Object} pos - Position object with x, y, and z values
+ * @return {Array} position array [x, y, z]
+ */
+const posToArray = (pos) => {
+    return [pos.x, pos.y, pos.z];
+};
+
+/** Returns the CW signed minimum difference between two angles on a ciscular buffer of 0 to 360.
+ *
+ * This function is commonly used to correctly compute longitude or azimuth differences.
+ *
+ * A positive value means that the minimum angle formed from the initial to the final position is CW.
+ * A negative value means that the minimum angle formed from the initial to the final position is CCW.
+ *
+ * @example
+ * // returns 20
+ * getAngleDiffSigned(350, 10);
+ * @example
+ * // returns -20
+ * globalNS.method(10, 350);
+ *
+ * @param {Number} initial The initial angle value in 0 to 360
+ * @param {Number} final The final angle value in 0 to 360
+ * @return {Number} The clock-wise signed minimum angle difference
+ */
+const getAngleDiffSigned = (initial, final) => {
+    const diff = final - initial;
+    const angle = Math.abs(diff);
+    const minAngle = Math.min(angle, 360 - angle);
+    let sign;
+
+    if (angle <= 180) {
+        sign = diff >= 0 ? 1 : -1;
+    } else {
+        sign = (diff - 360 * Math.sign(diff)) >= 0 ? 1 : -1;
+    }
+
+    return sign * minAngle;
+};
+
+export {
+    wrapOneRevUnsigned,
+    wrapHalfRevUnsigned,
+    wrapHalfRev,
+    wrapQuarterRev,
+    julianToGregorian,
+    epochToDate,
+    getMagnitude,
+    normalize,
+    transpose,
+    multiplyVector,
+    dist,
+    isValidDataMode,
+    isBoolean,
+    isNonEmptyString,
+    removeNullUndefined,
+    getTimeDifference,
+    isDefined,
+    wrapToRange,
+    getAngle,
+    getAngleDiffSigned,
+    posToArray,
+};