@berachain/berajs 0.1.1 → 0.2.0

package/src/utils/formatNumber.unit.test.ts

@@ -0,0 +1,246 @@
+import { describe, expect, it } from "vitest";
+
+import BigNumber from "@berachain/utils/pkg/bignumber.js";
+
+import { formatNumber } from "./formatNumber";
+
+describe("formatNumber", () => {
+  it("should return empty string for null input by default", () => {
+    const result = formatNumber(null);
+    expect(result).toBe("");
+  });
+
+  it("should return empty string for undefined input by default", () => {
+    const result = formatNumber(undefined);
+    expect(result).toBe("");
+  });
+
+  it("should return ifNullish text for null/undefined when provided", () => {
+    const result1 = formatNumber(null, { ifNullish: "N/A" });
+    expect(result1).toBe("N/A");
+
+    const result2 = formatNumber(undefined, { ifNullish: "No data" });
+    expect(result2).toBe("No data");
+  });
+
+  it("should format basic numbers", () => {
+    const result = formatNumber(123.456);
+    expect(result).toBe("123.46");
+  });
+
+  it("should format negative numbers", () => {
+    const result = formatNumber(-123.456);
+    expect(result).toBe("-123.46");
+  });
+
+  it("should format percentages", () => {
+    const result = formatNumber(0.1234, { percent: true });
+    expect(result).toBe("12.34%");
+  });
+
+  it("should handle zero", () => {
+    const result = formatNumber(0);
+    expect(result).toBe("0");
+  });
+
+  it("should detect and show smaller than minimum values", () => {
+    const result = formatNumber(0.000001, { visibleDecimals: 2 });
+    expect(result).toBe("<0.01");
+  });
+
+  it("should detect and show bigger than maximum values", () => {
+    const result = formatNumber(1000000, { maxValue: 100000 });
+    expect(result).toBe("∞");
+
+    const result2 = formatNumber(-1000000, { maxValue: 100000 });
+    expect(result2).toBe("-∞");
+  });
+
+  it("should use compact notation by default", () => {
+    const result = formatNumber(1500);
+    expect(result).toBe("1.50K");
+  });
+
+  it("should not use compact notation when disabled", () => {
+    const result = formatNumber(1500, { compact: false });
+    expect(result).toBe("1,500.00");
+  });
+
+  it("should respect compact threshold", () => {
+    const result = formatNumber(500, { compactThreshold: 1000 });
+    expect(result).toBe("500.00");
+  });
+
+  it("should handle rounding down", () => {
+    const result = formatNumber(123.789, {
+      visibleDecimals: 2,
+      roundDown: true,
+      compact: false,
+    });
+    expect(result).toBe("123.78");
+  });
+
+  it("should handle rounding up", () => {
+    const result = formatNumber(123.781, {
+      visibleDecimals: 2,
+      roundUp: true,
+      compact: false,
+    });
+    expect(result).toBe("123.79");
+  });
+
+  it("should auto-determine decimals for large numbers", () => {
+    const result = formatNumber(1000, { compact: false });
+    expect(result).toBe("1,000.00");
+  });
+
+  it("should auto-determine decimals for small numbers", () => {
+    const result = formatNumber(0.123456789, { compact: false });
+    expect(result).toBe("0.1234568");
+  });
+
+  it("should handle USD symbol", () => {
+    const result = formatNumber(123.45, { symbol: "USD", compact: false });
+    expect(result).toBe("$123.45");
+  });
+
+  it("should handle other symbols", () => {
+    const result = formatNumber(123.45, { symbol: "ETH", compact: false });
+    expect(result).toBe("123.45 ETH");
+  });
+
+  it("should handle BigNumber input", () => {
+    const input = new BigNumber("123.456");
+    const result = formatNumber(input);
+    expect(result).toBe("123.46");
+  });
+
+  it("should handle string input", () => {
+    const result = formatNumber("123.456");
+    expect(result).toBe("123.46");
+  });
+
+  it("should handle prefix text", () => {
+    const result = formatNumber(123.45, {
+      prefixText: "Value: ",
+      compact: false,
+    });
+    expect(result).toBe("Value: 123.45");
+  });
+
+  it("should handle suffix text", () => {
+    const result = formatNumber(123.45, { suffixText: " USD", compact: false });
+    expect(result).toBe("123.45 USD");
+  });
+
+  it("should handle percentage with symbol", () => {
+    const result = formatNumber(0.1234, { percent: true, compact: false });
+    expect(result).toBe("12.34%");
+  });
+
+  it("should handle USD symbol with percentage (no $ shown)", () => {
+    const result = formatNumber(0.1234, {
+      symbol: "USD",
+      percent: true,
+      compact: false,
+    });
+    expect(result).toBe("12.34%");
+  });
+
+  it("should show smaller than indicator for positive small values", () => {
+    const result = formatNumber(0.000001, {
+      visibleDecimals: 2,
+      compact: false,
+    });
+    expect(result).toBe("<0.01");
+  });
+
+  it("should show greater than indicator for negative small values", () => {
+    const result = formatNumber(-0.000001, {
+      visibleDecimals: 2,
+      compact: false,
+    });
+    expect(result).toBe(">-0.01");
+  });
+
+  it("should not show smaller than indicator when disabled", () => {
+    const result = formatNumber(0.000001, {
+      visibleDecimals: 2,
+      compact: false,
+      showIsSmallerThanMin: false,
+    });
+    expect(result).toBe("0.01");
+  });
+
+  it("should handle all options together", () => {
+    const result = formatNumber(123.45, {
+      prefixText: "Price: ",
+      suffixText: " total",
+      symbol: "USD",
+      compact: false,
+    });
+    expect(result).toBe("Price: $123.45 total");
+  });
+
+  it("should format compact numbers with K postfix", () => {
+    const result = formatNumber(1500, { visibleDecimals: 2 });
+    expect(result).toBe("1.50K");
+  });
+
+  it("should not use compact when not needed", () => {
+    const result = formatNumber(900, { visibleDecimals: 2 });
+    expect(result).toBe("900.00");
+  });
+
+  it("should format compact numbers with M postfix", () => {
+    const result = formatNumber(1500000, { visibleDecimals: 2 });
+    expect(result).toBe("1.50M");
+  });
+
+  it("should format compact numbers with B postfix", () => {
+    const result = formatNumber(1500000000, { visibleDecimals: 2 });
+    expect(result).toBe("1.50B");
+  });
+
+  it("should handle compact rounding down", () => {
+    const result = formatNumber(1237, { visibleDecimals: 2, roundDown: true });
+    expect(result).toBe("1.23K");
+  });
+
+  it("should handle compact rounding up", () => {
+    const result = formatNumber(1232, { visibleDecimals: 2, roundUp: true });
+    expect(result).toBe("1.24K");
+  });
+});
+
+describe("FormatNumber Edge cases", () => {
+  it("should handle very large numbers", () => {
+    const result = formatNumber(1e21);
+    expect(result).toContain("Z");
+  });
+
+  it("should handle very small positive numbers", () => {
+    const result = formatNumber(1e-10, { compact: false });
+    expect(result).toContain("<");
+  });
+
+  it("should handle very small negative numbers", () => {
+    const result = formatNumber(-1e-10, { compact: false });
+    expect(result).toContain(">");
+  });
+
+  it("should handle infinity", () => {
+    const result = formatNumber(Number.POSITIVE_INFINITY);
+    expect(result).toBe("Infinity");
+  });
+
+  it("should handle negative infinity", () => {
+    const result = formatNumber(Number.NEGATIVE_INFINITY);
+    expect(result).toBe("-Infinity");
+  });
+
+  it("should handle NaN", () => {
+    const result = formatNumber(Number.NaN);
+    expect(result).toBe("NaN");
+  });
+});

package/src/utils/formatTimestamps.ts

@@ -0,0 +1,155 @@
+export function calculateTimestampFromDays(daysRange: number): number {
+  const currentDate = new Date();
+  return currentDate.setDate(currentDate.getDate() - daysRange) * 1000;
+}
+
+const monthNames = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December",
+];
+
+const shortMonthNames = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec",
+];
+
+export function formatUnixTimestamp(unixTimestamp: number, isShort?: boolean) {
+  const date = new Date(unixTimestamp * 1000);
+
+  const day = date.getDate();
+  let daySuffix = "th";
+
+  if (day === 1 || day === 21 || day === 31) {
+    daySuffix = "st";
+  } else if (day === 2 || day === 22) {
+    daySuffix = "nd";
+  } else if (day === 3 || day === 23) {
+    daySuffix = "rd";
+  }
+
+  if (isShort) {
+    return `${shortMonthNames[date.getMonth()]} ${day}`;
+  }
+
+  return `${
+    monthNames[date.getMonth()]
+  } ${day}${daySuffix}, ${date.getFullYear()}`;
+}
+
+type LegacyArgs = [number, boolean?, boolean?, boolean?];
+type FormatTimeLeftArgs = [
+  number,
+  {
+    condensed?: boolean;
+    greaterUnit?: "days" | "hours" | "minutes";
+    showSeconds?: boolean;
+  },
+];
+
+/**
+ * Formats the time left into a string like "8 hours, 23 minutes".
+ *
+ * @param timeLeftInSeconds - The time left in seconds.
+ * @returns A formatted string representing the time left.
+ */
+export function formatTimeLeft(
+  ...args: FormatTimeLeftArgs | LegacyArgs
+): string {
+  const timeLeftInSeconds = args[0];
+  let condensed: boolean;
+
+  let showDays: boolean;
+
+  let showMinutes: boolean;
+  let showSeconds: boolean;
+
+  if (typeof args[1] !== "object") {
+    condensed = args[1] ?? false;
+    showDays = args[2] ?? false;
+    showSeconds = args[3] ?? false;
+    showMinutes = true;
+  } else {
+    const opts = args[1];
+    condensed = opts.condensed ?? false;
+    const greaterUnit = opts.greaterUnit ?? "hours";
+
+    if (greaterUnit === "days") {
+      showDays = true;
+      showMinutes = true;
+    } else if (greaterUnit === "hours") {
+      showDays = false;
+      showMinutes = true;
+      showSeconds = false;
+    } else {
+      // minutes is the default
+      showDays = false;
+      showMinutes = true;
+    }
+    showSeconds = opts.showSeconds ?? false;
+  }
+
+  let days = Math.floor(timeLeftInSeconds / (3600 * 24));
+  let hours = Math.floor((timeLeftInSeconds % (3600 * 24)) / 3600);
+  const minutes = Math.floor((timeLeftInSeconds % 3600) / 60);
+  const seconds = timeLeftInSeconds % 60;
+
+  // If showDays=false, roll days into hours
+  if (!showDays) {
+    hours += days * 24;
+    days = 0;
+  }
+
+  if (days === 0 && hours === 0 && minutes === 0) {
+    return condensed ? "< 1 M" : "less than a minute";
+  }
+
+  const daysDisplay =
+    days > 0
+      ? `${days}${condensed ? "D" : " day"}${
+          !condensed && days !== 1 ? "s" : ""
+        }`
+      : "";
+
+  const hoursDisplay =
+    hours > 0
+      ? `${hours}${condensed ? "H" : " hour"}${
+          !condensed && hours !== 1 ? "s" : ""
+        }`
+      : "";
+
+  const minutesDisplay =
+    (minutes > 0 && showMinutes) || (!days && !hours)
+      ? `${minutes}${condensed ? "M" : " minute"}${
+          !condensed && minutes !== 1 ? "s" : ""
+        }`
+      : "";
+  const secondsDisplay =
+    seconds > 0 && showSeconds
+      ? `${seconds}${condensed ? "S" : " second"}${
+          !condensed && seconds !== 1 ? "s" : ""
+        }`
+      : "";
+  return [daysDisplay, hoursDisplay, minutesDisplay, secondsDisplay]
+    .filter(Boolean)
+    .join(condensed ? " " : ", ");
+}