@synnaxlabs/x 0.44.2 → 0.44.3

package/src/math/math.ts

@@ -10,27 +10,38 @@
 /** A numeric value is either a a number, or a bigint. */
 export type Numeric = number | bigint;
 
+const multiCoercedOp =
+  (func: (a: number, b: number) => Numeric) =>
+  <V extends Numeric>(a: V, b: Numeric): V => {
+    if (typeof a === "bigint") {
+      if (isInteger(b))
+        return func(a as unknown as number, BigInt(b) as unknown as number) as V;
+      const res = func(Number(a), Number(b)) as number;
+      if (typeof res === "number") return BigInt(Math.round(res)) as V;
+      return res;
+    }
+    return func(Number(a), Number(b)) as V;
+  };
+
 /**
  * @returns the product of a and b, coercing b to the type of a if necessary. */
-export const sub = <V extends Numeric>(a: V, b: Numeric): V => {
-  if (typeof a === "bigint") return (a - BigInt(b)) as V;
-  return (a - Number(b)) as V;
-};
+export const sub = multiCoercedOp((a, b) => a - b);
 
 /** @returns the sum of a and b, coercing b to the type of a if necessary. */
-export const add = <V extends Numeric>(a: V, b: Numeric): V => {
-  if (typeof a === "bigint") return (a + BigInt(b)) as V;
-  return ((a as unknown as number) + Number(b)) as V;
-};
+export const add = multiCoercedOp((a, b) => a + b);
 
 /** @returns true if a is close to b within epsilon. */
 export const closeTo = (a: number, b: number, epsilon = 0.0001): boolean =>
   Math.abs(a - b) < epsilon;
 
 /** @returns true if a is equal to b, coercing b to the type of a if necessary. */
-export const equal = <V extends Numeric>(a: V, b: Numeric): boolean => {
-  if (typeof a === "bigint") return a === BigInt(b);
-  return a === Number(b);
+export const equal = (a: Numeric, b: Numeric): boolean => {
+  const aIsBigInt = typeof a === "bigint";
+  const bIsBigInt = typeof b === "bigint";
+  if (aIsBigInt && bIsBigInt) return a === b;
+  if (aIsBigInt && isInteger(b)) return a === BigInt(b);
+  if (bIsBigInt && isInteger(a)) return b === BigInt(a);
+  return a === b;
 };
 
 /**
@@ -45,32 +56,24 @@ export const roundToNearestMagnitude = (num: number): number => {
 };
 
 /** @returns the minimum of a and b, coercing b to the type of a if necessary. */
-export const min = <V extends Numeric>(a: V, b: Numeric): V => {
-  if (a <= b) return a;
-  if (typeof a === "bigint") return (a <= b ? a : BigInt(b)) as V;
-  return (a <= b ? a : Number(b)) as V;
+export const min = multiCoercedOp((a, b) => (a <= b ? a : b));
+
+export const isInteger = (a: Numeric): boolean => {
+  if (typeof a === "bigint") return true;
+  return Number.isInteger(a);
 };
 
 /** @returns the maximum of a and b, coercing b to the type of a if necessary. */
-export const max = <V extends Numeric>(a: V, b: Numeric): V => {
-  if (typeof a === "bigint") return (a >= b ? a : BigInt(b)) as V;
-  return (a >= b ? a : Number(b)) as V;
-};
+export const max = multiCoercedOp((a, b) => (a >= b ? a : b));
 
 /** @returns the absolute value of a. */
 export const abs = <V extends Numeric>(a: V): V => {
-  if (a < 0) return -a as V;
-  return a;
+  if (typeof a === "bigint") return (a < 0n ? -a : a) as V;
+  return (a < 0 ? -a : a) as V;
 };
 
 /** @returns the multiplication of a and b, coercing b to the type of a if necessary. */
-export const mult = <V extends Numeric>(a: V, b: Numeric): V => {
-  if (typeof a === "bigint") return (a * BigInt(b)) as V;
-  return (a * Number(b)) as V;
-};
+export const mult = multiCoercedOp((a, b) => a * b);
 
 /** @returns the division of a and b, coercing b to the type of a if necessary. */
-export const div = <V extends Numeric>(a: V, b: Numeric): V => {
-  if (typeof a === "bigint") return (a / BigInt(b)) as V;
-  return (a / Number(b)) as V;
-};
+export const div = multiCoercedOp((a, b) => a / b);

package/src/spatial/bounds/bounds.ts

@@ -615,7 +615,7 @@ export const traverse = <T extends numeric.Value = number>(
           currentPosition,
           dir > 0 ? moveDist : -moveDist,
         ) as T;
-        remainingDist = math.sub(remainingDist, dir > 0 ? moveDist : -moveDist);
+        remainingDist = math.sub<T>(remainingDist, dir > 0 ? moveDist : -moveDist);
 
         // If we've exhausted the distance, return the current position
         if (math.equal(remainingDist, 0)) return currentPosition as T;

package/src/status/status.ts

@@ -89,3 +89,14 @@ export const create = <D = undefined, V extends Variant = Variant>(
     time: TimeStamp.now(),
     ...spec,
   }) as unknown as Status<D, V>;
+
+export const filterVariant = (
+  variant: Variant,
+  only: Variant | Variant[] = [],
+): Variant | undefined => {
+  if (Array.isArray(only)) {
+    if (only.includes(variant)) return variant;
+    return undefined;
+  }
+  return only === variant ? variant : undefined;
+};

package/src/strings/strings.spec.ts

@@ -15,6 +15,9 @@ describe("naturalLanguageJoin", () => {
   it("should return an empty string for an empty array", () =>
     expect(strings.naturalLanguageJoin([])).toBe(""));
 
+  it("should return the string for a single string", () =>
+    expect(strings.naturalLanguageJoin("apple")).toBe("apple"));
+
   it("should return the zeroLength string for an empty array if provided", () =>
     expect(strings.naturalLanguageJoin([], "No items")).toBe("No items"));
 

package/src/strings/strings.ts

@@ -24,9 +24,10 @@
  * ```
  */
 export const naturalLanguageJoin = (
-  strings: string[],
+  strings: string | string[],
   zeroLength: string = "",
 ): string => {
+  if (typeof strings === "string") return strings;
   const length = strings.length;
   if (length === 0) return zeroLength;
   if (length === 1) return strings[0];