uom-types 2.0.0 → 3.0.1

package/dist/{functions-ho.d.mts → functions-higher-order.d.mts}

@@ -1,54 +1,83 @@
-import { Multiply, Divide, UnknownUnit, Inverse, DivideUnitExponents } from './index.mjs';
-import { Decimal } from './si-units.mjs';
+import { M as Multiply, D as Divide, U as UnknownUnit, b as UnknownAbstractUnit, I as Inverse, a as Unit, A as AbstractUnit, c as DivideUnitExponents } from './_index.mjs';
 
-type OperationIO<T extends number> = T extends UnknownUnit ? T : number;
 /**
- * Add a value by the given value.
+ * @module uom-types/functions/higher-order
+ */
+
+type OperationIO<T extends number> = [T] extends [
+    UnknownUnit | UnknownAbstractUnit
+] ? T : number;
+/**
+ * Add two values with the same units together.
+ *
+ * @category Math
  */
 declare function add<T extends number>(a: OperationIO<T>): (b: OperationIO<T>) => OperationIO<T>;
 /**
- * Subtract one value from the given value.
+ * Subtract one value from another with the same units.
+ *
+ * @category Math
  */
 declare function sub<T extends number>(a: OperationIO<T>): (b: OperationIO<T>) => OperationIO<T>;
 /**
  * Multiple a value by the given value.
+ *
+ * @category Math
  */
-declare function mul<A extends number>(a: OperationIO<A>): <B extends number>(b: OperationIO<B>) => OperationIO<Multiply<B, A>>;
+declare function mul<A extends number>(a: A): <B extends number>(b: B) => Multiply<B, A>;
 /**
  * Divide one value by the given value.
+ *
+ * @category Math
  */
-declare function div<A extends number>(a: OperationIO<A>): <B extends number>(b: OperationIO<B>) => OperationIO<Divide<B, A>>;
+declare function div<A extends number>(a: A): <B extends number>(b: B) => Divide<B, A>;
 /**
  * Modulo operator.
+ *
+ * @category Math
  */
 declare function mod<T extends number>(a: OperationIO<T>): (b: OperationIO<T>) => OperationIO<T>;
 /**
  * Perform mathematic modular arithmetic.
+ *
+ * @category Math
  */
 declare function modSafe<T extends number>(a: OperationIO<T>): (b: OperationIO<T>) => OperationIO<T>;
-type PowFunction<E extends number, B extends number> = E extends UnknownUnit ? never : E extends -1 ? (b: OperationIO<B>) => OperationIO<Inverse<B>> : E extends 0 ? (b: OperationIO<B>) => OperationIO<B> extends UnknownUnit ? Decimal : 1 : E extends 0.5 ? (b: OperationIO<B>) => OperationIO<DivideUnitExponents<B, 2>> : E extends 1 ? (b: OperationIO<B>) => OperationIO<B> : E extends 2 ? (b: OperationIO<B>) => OperationIO<Multiply<B, B>> : E extends 3 ? (b: OperationIO<B>) => OperationIO<Multiply<B, Multiply<B, B>>> : E extends 4 ? (b: OperationIO<B>) => OperationIO<Multiply<B, Multiply<B, Multiply<B, B>>>> : (b: OperationIO<B>) => OperationIO<number>;
+type PowFunction<E extends number, B extends number> = E extends UnknownUnit ? never : E extends UnknownAbstractUnit ? never : E extends -1 ? (b: B) => Inverse<B> : E extends 0 ? (b: B) => B extends UnknownUnit ? Unit<{}> : B extends UnknownAbstractUnit ? AbstractUnit<{}> : 1 : E extends 0.5 ? (b: B) => DivideUnitExponents<B, 2> : E extends 1 ? (b: B) => B : E extends 2 ? (b: B) => Multiply<B, B> : E extends 3 ? (b: B) => Multiply<B, Multiply<B, B>> : E extends 4 ? (b: B) => Multiply<B, Multiply<B, Multiply<B, B>>> : (b: B) => number;
 /**
  * Put a number to the power of the given value.
+ *
+ * @category Math
  */
 declare function pow<E extends number>(exponent: E): <B extends number>(base: Parameters<PowFunction<E, B>>[0]) => ReturnType<PowFunction<E, B>>;
 /**
  * Equal: Compare if a value is equal to the given value.
+ *
+ * @category Math
  */
 declare function eq<T extends number>(a: OperationIO<T>): (b: OperationIO<T>) => boolean;
 /**
  * Greater Than: Compare if a value is greater than the given value.
+ *
+ * @category Math
  */
 declare function gt<T extends number>(a: OperationIO<T>): (b: OperationIO<T>) => boolean;
 /**
  * Greater Than or Equal: Compare if a value is greater than or equal to the given value.
+ *
+ * @category Math
  */
 declare function gte<T extends number>(a: OperationIO<T>): (b: OperationIO<T>) => boolean;
 /**
  * Less Than: Compare if a value is less than the given value.
+ *
+ * @category Math
  */
 declare function lt<T extends number>(a: OperationIO<T>): (b: OperationIO<T>) => boolean;
 /**
  * Less Than or Equal: Compare if a value is less than or equal to the given value.
+ *
+ * @category Math
  */
 declare function lte<T extends number>(a: OperationIO<T>): (b: OperationIO<T>) => boolean;
 

package/dist/{functions-ho.mjs → functions-higher-order.mjs}

@@ -1,73 +1,100 @@
 /**
- * Add a value by the given value.
+ * @module uom-types/functions/higher-order
+ */
+/**
+ * Add two values with the same units together.
+ *
+ * @category Math
  */
 function add(a) {
     return (b) => (b + a);
 }
 /**
- * Subtract one value from the given value.
+ * Subtract one value from another with the same units.
+ *
+ * @category Math
  */
 function sub(a) {
     return (b) => (b - a);
 }
 /**
  * Multiple a value by the given value.
+ *
+ * @category Math
  */
 function mul(a) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Casting to actual type fails for some reason.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return -- Casting to actual type fails for some reason.
     return (b) => (b * a);
 }
 /**
  * Divide one value by the given value.
+ *
+ * @category Math
  */
 function div(a) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Casting to actual type fails for some reason.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return -- Casting to actual type fails for some reason.
     return (b) => (b / a);
 }
 /**
  * Modulo operator.
+ *
+ * @category Math
  */
 function mod(a) {
     return (b) => (b % a);
 }
 /**
  * Perform mathematic modular arithmetic.
+ *
+ * @category Math
  */
 function modSafe(a) {
     return (b) => (((b % a) + a) % a);
 }
 /**
  * Put a number to the power of the given value.
+ *
+ * @category Math
  */
 function pow(exponent) {
     return (base) => (base ** exponent);
 }
 /**
  * Equal: Compare if a value is equal to the given value.
+ *
+ * @category Math
  */
 function eq(a) {
     return (b) => b === a;
 }
 /**
  * Greater Than: Compare if a value is greater than the given value.
+ *
+ * @category Math
  */
 function gt(a) {
     return (b) => b > a;
 }
 /**
  * Greater Than or Equal: Compare if a value is greater than or equal to the given value.
+ *
+ * @category Math
  */
 function gte(a) {
     return (b) => b >= a;
 }
 /**
  * Less Than: Compare if a value is less than the given value.
+ *
+ * @category Math
  */
 function lt(a) {
     return (b) => b < a;
 }
 /**
  * Less Than or Equal: Compare if a value is less than or equal to the given value.
+ *
+ * @category Math
  */
 function lte(a) {
     return (b) => b <= a;

package/dist/functions.cjs

@@ -1,25 +1,36 @@
 'use strict';
 
 /**
- * Add two values together.
+ * @module uom-types/functions
+ */
+/**
+ * Add two values with the same units together.
+ *
+ * @category Math
  */
 function add(a, b) {
     return (a + b);
 }
 /**
- * Subtract one value from another.
+ * Subtract one value from another with the same units.
+ *
+ * @category Math
  */
 function sub(a, b) {
     return (a - b);
 }
 /**
  * Multiple two values together.
+ *
+ * @category Math
  */
 function mul(a, b) {
     return (a * b);
 }
 /**
  * Divide one value by another.
+ *
+ * @category Math
  */
 function div(a, b) {
     return (a / b);
@@ -27,6 +38,7 @@ function div(a, b) {
 /**
  * Modulo operator.
  *
+ * @category Math
  * @param a - Must be an integer.
  * @param b - Must be an integer.
  * @returns `a % b`
@@ -37,6 +49,7 @@ function mod(a, b) {
 /**
  * Perform mathematic modular arithmetic.
  *
+ * @category Math
  * @param a - Must be an integer.
  * @param b - Must be a positive integer.
  * @returns An integer between zero (inclusive) and `b` (exclusive).
@@ -49,98 +62,243 @@ function pow(base, exponent) {
 }
 /**
  * Take the square root of the given value.
+ *
+ * @category Math
  */
 function sqrt(value) {
     return pow(value, 0.5);
 }
 /**
  * Inverse the given value.
+ *
+ * @category Math
  */
 function inverse(value) {
     return pow(value, -1);
 }
 /**
- * Make the given value negative.
+ * Returns the negative of the given value.
+ *
+ * @category Math
  */
 function negate(value) {
     return -value;
 }
 /**
- * Returns the absolute value of a number.
+ * Returns the absolute value of the given value.
+ *
+ * @category Math
  */
 function abs(value) {
     return Math.abs(value);
 }
 /**
  * Returns the greatest integer less than or equal to the given value.
+ *
+ * @category Math
  */
 function floor(value) {
     return Math.floor(value);
 }
 /**
  * Returns the smallest integer greater than or equal the given value.
+ *
+ * @category Math
  */
 function ceil(value) {
     return Math.ceil(value);
 }
 /**
  * Returns the given value rounded to the nearest integer.
+ *
+ * @category Math
  */
 function round(value) {
     return Math.round(value);
 }
 /**
  * Returns the larger value in the given collection.
+ *
+ * @category Math
  */
 function max(values) {
     return Math.max(...values);
 }
 /**
  * Returns the smallest value in the given collection.
+ *
+ * @category Math
  */
 function min(values) {
     return Math.min(...values);
 }
 /**
  * Takes the sum of all the values in the given collection.
+ *
+ * @category Math
  */
 function sum(values) {
-    return values.reduce((add), 0);
+    return [...values].reduce(add, 0);
 }
 /**
  * Equal: Compare if two values are equal.
+ *
+ * @category Math
  */
 function eq(a, b) {
     return a === b;
 }
 /**
  * Greater Than: Compare if the first value is greater than the second.
+ *
+ * @category Math
  */
 function gt(a, b) {
     return a > b;
 }
 /**
  * Greater Than or Equal: Compare if the first value is greater than or equal to the second.
+ *
+ * @category Math
  */
 function gte(a, b) {
     return a >= b;
 }
 /**
  * Less Than: Compare if the first value is less than the second.
+ *
+ * @category Math
  */
 function lt(a, b) {
     return a < b;
 }
 /**
  * Less Than or Equal: Compare if the first value is less than or equal to the second.
+ *
+ * @category Math
  */
 function lte(a, b) {
     return a <= b;
 }
+/**
+ * Returns the sine of a number.
+ *
+ * @category Math
+ */
+function sin(angle) {
+    return Math.sin(angle);
+}
+/**
+ * Returns the cosine of a number.
+ *
+ * @category Math
+ */
+function cos(angle) {
+    return Math.cos(angle);
+}
+/**
+ * Returns the tangent of a number.
+ *
+ * @category Math
+ */
+function tan(angle) {
+    return Math.tan(angle);
+}
+/**
+ * Returns the arcsine of a number.
+ *
+ * @category Math
+ */
+function asin(value) {
+    return Math.asin(value);
+}
+/**
+ * Returns the arc cosine (or inverse cosine) of a number.
+ *
+ * @category Math
+ */
+function acos(value) {
+    return Math.acos(value);
+}
+/**
+ * Returns the arctangent of a number.
+ *
+ * @category Math
+ */
+function atan(value) {
+    return Math.atan(value);
+}
+/**
+ * Returns the angle (in radians) from the X axis to a point.
+ *
+ * @category Math
+ * @param x - A number representing the cartesian x-coordinate.
+ * @param y - A number representing the cartesian y-coordinate.
+ */
+function atan2(x, y) {
+    return Math.atan2(x, y);
+}
+/**
+ * Returns the hyperbolic sine of a number.
+ *
+ * @category Math
+ */
+function sinh(angle) {
+    return Math.sinh(angle);
+}
+/**
+ * Returns the hyperbolic cosine of a number.
+ *
+ * @category Math
+ */
+function cosh(angle) {
+    return Math.cosh(angle);
+}
+/**
+ * Returns the hyperbolic tangent of a number.
+ *
+ * @category Math
+ */
+function tanh(angle) {
+    return Math.tanh(angle);
+}
+/**
+ * Returns the inverse hyperbolic sine of a number.
+ *
+ * @category Math
+ */
+function asinh(value) {
+    return Math.asinh(value);
+}
+/**
+ * Returns the inverse hyperbolic cosine of a number.
+ *
+ * @category Math
+ */
+function acosh(value) {
+    return Math.acosh(value);
+}
+/**
+ * Returns the inverse hyperbolic tangent of a number.
+ *
+ * @category Math
+ */
+function atanh(value) {
+    return Math.atanh(value);
+}
 
 exports.abs = abs;
+exports.acos = acos;
+exports.acosh = acosh;
 exports.add = add;
+exports.asin = asin;
+exports.asinh = asinh;
+exports.atan = atan;
+exports.atan2 = atan2;
+exports.atanh = atanh;
 exports.ceil = ceil;
+exports.cos = cos;
+exports.cosh = cosh;
 exports.div = div;
 exports.eq = eq;
 exports.floor = floor;
@@ -157,6 +315,10 @@ exports.mul = mul;
 exports.negate = negate;
 exports.pow = pow;
 exports.round = round;
+exports.sin = sin;
+exports.sinh = sinh;
 exports.sqrt = sqrt;
 exports.sub = sub;
 exports.sum = sum;
+exports.tan = tan;
+exports.tanh = tanh;