@synnaxlabs/x 0.52.4 → 0.52.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@synnaxlabs/x",
-  "version": "0.52.4",
+  "version": "0.52.5",
   "type": "module",
   "description": "Common Utilities for Synnax Labs",
   "repository": "https://github.com/synnaxlabs/synnax/tree/main/x/ts",

package/src/math/round.spec.ts

@@ -14,74 +14,6 @@ import { describe, expect, it } from "vitest";
 import { math } from "@/math";
 import { type bounds } from "@/spatial";
 
-interface TestCase {
-  name: string;
-  value: number;
-  bounds: bounds.Bounds<number>;
-  expected: number;
-}
-
-const TEST_CASES: TestCase[] = [
-  {
-    name: "should handle large spans (>= 1000)",
-    value: 1234.5678,
-    bounds: { lower: 0, upper: 2000 },
-    expected: 1234.57,
-  },
-  {
-    name: "should handle medium spans (>= 1)",
-    value: 1.23456,
-    bounds: { lower: 0, upper: 2 },
-    expected: 1.235,
-  },
-  {
-    name: "should handle small spans (< 1)",
-    value: 0.123456,
-    bounds: { lower: 0, upper: 0.2 },
-    expected: 0.123,
-  },
-  {
-    name: "should handle very small spans",
-    value: 0.0001234,
-    bounds: { lower: 0, upper: 0.0002 },
-    expected: 0.000123,
-  },
-  {
-    name: "should handle negative values",
-    value: -1.23456,
-    bounds: { lower: -2, upper: 0 },
-    expected: -1.235,
-  },
-  {
-    name: "should handle NaN",
-    value: NaN,
-    bounds: { lower: 0, upper: 1 },
-    expected: NaN,
-  },
-  {
-    name: "should handle Infinity",
-    value: Infinity,
-    bounds: { lower: 0, upper: 1 },
-    expected: Infinity,
-  },
-  {
-    name: "should handle zero span bounds",
-    value: 1.23456,
-    bounds: { lower: 1, upper: 1 },
-    expected: 1.23456,
-  },
-];
-
-describe("roundBySpan", () => {
-  TEST_CASES.forEach(({ name, value, bounds, expected }) => {
-    it(name, () => {
-      const result = math.roundBySpan(value, bounds);
-      if (Number.isNaN(expected)) expect(Number.isNaN(result)).toBe(true);
-      else expect(result).toBe(expected);
-    });
-  });
-});
-
 interface SmartRoundTestCase {
   value: number;
   bounds?: bounds.Bounds<number>;

package/src/math/round.ts

@@ -15,58 +15,6 @@ const MEDIUM_SPAN_DECIMAL_PLACES = 3;
 // The number of additional decimal places to show past the precision of the span.
 const EXTRA_DECIMAL_PLACES = 2;
 
-/**
- * Rounds a number  based on the span of the provided bounds. The function adjusts the
- * number of decimal places based on the magnitude of the bounds.
- *
- * @param value - The number to be rounded.
- * @param bounds - The bounds object containing the min and max values that provide
- * context for rounding.
- * @returns The rounded number.
- *
- * Rules for decimal places:
- * - For spans >= 1000: 2 decimal places
- * - For spans >= 1: 3 decimal places
- * - For spans < 1: 2 decimal places + 2 decimal places past the precision of the span
- *
- * Edge cases:
- * - If the value is `NaN`, returns `NaN`
- * - If the value is `Infinity` or `-Infinity`, returns the original value
- * - If the bounds span is 0, returns the original value
- *
- * Examples:
- * ```typescript
- * // Large spans (>= 1000) use 2 decimal places
- * roundBySpan(1234.5678, { start: 0, end: 2000 }); // 1200
- *
- * // Medium spans (>= 1) use 3 decimal places
- * roundBySpan(1.23456, { start: 0, end: 2 }); // 1.235
- *
- * // Small spans (< 1) adapt based on the span
- * roundBySpan(0.123456, { start: 0, end: 0.2 }); // 0.123 = 1 + 2 decimal places
- * roundBySpan(0.0001234, { start: 0, end: 0.001 }); // 0.00012 = 3 + 2 decimal places
- *
- * // Edge cases
- * roundBySpan(NaN, { start: 0, end: 1 }); // NaN
- * roundBySpan(Infinity, { start: 0, end: 1 }); // Infinity
- * roundBySpan(123, { start: 1, end: 1 }); // 123 (span is 0)
- * ```
- */
-export const roundBySpan = (value: number, b: bounds.Bounds<number>): number => {
-  if (Number.isNaN(value) || !Number.isFinite(value)) return value;
-  const span = bounds.span(b);
-  if (span == 0) return value;
-  let decimalPlaces: number;
-  if (span >= 1000) decimalPlaces = LARGE_SPAN_DECIMAL_PLACES;
-  else if (span >= 1) decimalPlaces = MEDIUM_SPAN_DECIMAL_PLACES;
-  else {
-    const decimalPlacesInSpan = Math.ceil(-Math.log10(span));
-    decimalPlaces = decimalPlacesInSpan + EXTRA_DECIMAL_PLACES;
-  }
-  const multiplier = 10 ** decimalPlaces;
-  return Math.round(value * multiplier) / multiplier;
-};
-
 const SIGNIFICANT_FIGURES = 5;
 const MIN_SPAN_THRESHOLD = 1e-10;