@ooneex/utils 0.0.6 → 0.1.0

package/tests/formatRelativeNumber.spec.ts

@@ -1,303 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { formatRelativeNumber } from "@/index";
-
-describe("formatRelativeNumber", () => {
-  describe("basic functionality", () => {
-    test("should format small numbers without compacting", () => {
-      expect(formatRelativeNumber(42)).toBe("42");
-      expect(formatRelativeNumber(123)).toBe("123");
-      expect(formatRelativeNumber(999)).toBe("999");
-    });
-
-    test("should format thousands with K suffix", () => {
-      expect(formatRelativeNumber(1000)).toBe("1K");
-      expect(formatRelativeNumber(1500)).toBe("1.5K");
-      expect(formatRelativeNumber(2300)).toBe("2.3K");
-      expect(formatRelativeNumber(10000)).toBe("10K");
-      expect(formatRelativeNumber(50000)).toBe("50K");
-      expect(formatRelativeNumber(999000)).toBe("999K");
-    });
-
-    test("should format millions with M suffix", () => {
-      expect(formatRelativeNumber(1000000)).toBe("1M");
-      expect(formatRelativeNumber(1500000)).toBe("1.5M");
-      expect(formatRelativeNumber(2300000)).toBe("2.3M");
-      expect(formatRelativeNumber(10000000)).toBe("10M");
-      expect(formatRelativeNumber(999000000)).toBe("999M");
-    });
-
-    test("should format billions with B suffix", () => {
-      expect(formatRelativeNumber(1000000000)).toBe("1B");
-      expect(formatRelativeNumber(1500000000)).toBe("1.5B");
-      expect(formatRelativeNumber(2300000000)).toBe("2.3B");
-    });
-
-    test("should format trillions with T suffix", () => {
-      expect(formatRelativeNumber(1000000000000)).toBe("1T");
-      expect(formatRelativeNumber(1500000000000)).toBe("1.5T");
-    });
-  });
-
-  describe("precision configuration", () => {
-    test("should respect precision 0", () => {
-      expect(formatRelativeNumber(1500, { precision: 0 })).toBe("2K");
-      expect(formatRelativeNumber(1500000, { precision: 0 })).toBe("2M");
-      expect(formatRelativeNumber(2300000, { precision: 0 })).toBe("2M");
-    });
-
-    test("should respect precision 1 (default)", () => {
-      expect(formatRelativeNumber(1500)).toBe("1.5K");
-      expect(formatRelativeNumber(1500, { precision: 1 })).toBe("1.5K");
-      expect(formatRelativeNumber(2300000)).toBe("2.3M");
-    });
-
-    test("should respect precision 2", () => {
-      expect(formatRelativeNumber(1234, { precision: 2 })).toBe("1.23K");
-      expect(formatRelativeNumber(1234567, { precision: 2 })).toBe("1.23M");
-      expect(formatRelativeNumber(9876543, { precision: 2 })).toBe("9.88M");
-    });
-
-    test("should respect precision 3", () => {
-      expect(formatRelativeNumber(1234, { precision: 3 })).toBe("1.234K");
-      expect(formatRelativeNumber(1234567, { precision: 3 })).toBe("1.235M");
-    });
-
-    test("should handle precision 0 with edge cases", () => {
-      expect(formatRelativeNumber(1499, { precision: 0 })).toBe("1K");
-      expect(formatRelativeNumber(1999, { precision: 0 })).toBe("2K");
-    });
-  });
-
-  describe("language configuration", () => {
-    test("should use en-GB as default", () => {
-      expect(formatRelativeNumber(1500)).toBe("1.5K");
-      expect(formatRelativeNumber(1500000)).toBe("1.5M");
-    });
-
-    test("should format with en-US locale", () => {
-      expect(formatRelativeNumber(1500, { lang: "en-US" })).toBe("1.5K");
-      expect(formatRelativeNumber(1500000, { lang: "en-US" })).toBe("1.5M");
-    });
-
-    test("should format with de-DE locale", () => {
-      // German has different compact notation thresholds
-      expect(formatRelativeNumber(1500, { lang: "de-DE" })).toBe("1500");
-      expect(formatRelativeNumber(1500000, { lang: "de-DE" })).toBe("1,5\u00A0Mio.");
-      expect(formatRelativeNumber(10000, { lang: "de-DE" })).toBe("10.000");
-    });
-
-    test("should format with fr-FR locale", () => {
-      expect(formatRelativeNumber(1500, { lang: "fr-FR" })).toBe("1,5\u00A0k");
-      expect(formatRelativeNumber(1500000, { lang: "fr-FR" })).toBe("1,5\u00A0M");
-    });
-
-    test("should format with es-ES locale", () => {
-      expect(formatRelativeNumber(1500, { lang: "es-ES" })).toBe("1,5\u00A0mil");
-      expect(formatRelativeNumber(1500000, { lang: "es-ES" })).toBe("1,5\u00A0M");
-    });
-
-    test("should format with ja-JP locale", () => {
-      // Japanese has different compact notation behavior for smaller numbers
-      expect(formatRelativeNumber(1500, { lang: "ja-JP" })).toBe("1500");
-      expect(formatRelativeNumber(1500000, { lang: "ja-JP" })).toBe("150万");
-      expect(formatRelativeNumber(10000, { lang: "ja-JP" })).toBe("1万");
-    });
-
-    test("should handle locale-specific compact notation thresholds", () => {
-      // Test numbers where compact notation definitely applies across locales
-      expect(formatRelativeNumber(100000, { lang: "de-DE" })).toBe("100.000");
-      expect(formatRelativeNumber(100000, { lang: "fr-FR" })).toBe("100\u00A0k");
-      expect(formatRelativeNumber(100000, { lang: "es-ES" })).toBe("100\u00A0mil");
-      expect(formatRelativeNumber(100000, { lang: "ja-JP" })).toBe("10万");
-    });
-  });
-
-  describe("combined configuration", () => {
-    test("should use both precision and language", () => {
-      expect(formatRelativeNumber(1234, { precision: 2, lang: "en-US" })).toBe("1.23K");
-      expect(formatRelativeNumber(1234, { precision: 2, lang: "de-DE" })).toBe("1234");
-      expect(formatRelativeNumber(1234567, { precision: 0, lang: "fr-FR" })).toBe("1\u00A0M");
-    });
-
-    test("should handle edge cases with configuration", () => {
-      expect(formatRelativeNumber(999999, { precision: 3, lang: "en-GB" })).toBe("999.999K");
-      expect(formatRelativeNumber(1000000, { precision: 3, lang: "en-GB" })).toBe("1M");
-    });
-  });
-
-  describe("edge cases", () => {
-    test("should handle zero", () => {
-      expect(formatRelativeNumber(0)).toBe("0");
-      expect(formatRelativeNumber(0, { precision: 2 })).toBe("0");
-    });
-
-    test("should handle negative numbers", () => {
-      expect(formatRelativeNumber(-42)).toBe("-42");
-      expect(formatRelativeNumber(-1500)).toBe("-1.5K");
-      expect(formatRelativeNumber(-1500000)).toBe("-1.5M");
-    });
-
-    test("should handle decimal inputs", () => {
-      expect(formatRelativeNumber(1.5)).toBe("1.5");
-      expect(formatRelativeNumber(999.9)).toBe("999.9");
-      expect(formatRelativeNumber(1000.5)).toBe("1K");
-    });
-
-    test("should handle very small positive numbers", () => {
-      expect(formatRelativeNumber(0.1)).toBe("0.1");
-      expect(formatRelativeNumber(0.01)).toBe("0");
-      expect(formatRelativeNumber(0.99)).toBe("1");
-    });
-
-    test("should handle very large numbers", () => {
-      expect(formatRelativeNumber(1e15)).toBe("1000T");
-      expect(formatRelativeNumber(1e18)).toBe("1,000,000T");
-    });
-
-    test("should handle Number.MAX_SAFE_INTEGER", () => {
-      const result = formatRelativeNumber(Number.MAX_SAFE_INTEGER);
-      expect(typeof result).toBe("string");
-      expect(result).toMatch(/\d+(\.\d+)?[KMBT]/);
-    });
-
-    test("should handle Number.MIN_SAFE_INTEGER", () => {
-      const result = formatRelativeNumber(Number.MIN_SAFE_INTEGER);
-      expect(typeof result).toBe("string");
-      expect(result).toMatch(/-\d+(\.\d+)?[KMBT]/);
-    });
-  });
-
-  describe("parametrized tests", () => {
-    test.each([
-      [0, "0"],
-      [1, "1"],
-      [10, "10"],
-      [100, "100"],
-      [1000, "1K"],
-      [10000, "10K"],
-      [100000, "100K"],
-      [1000000, "1M"],
-      [10000000, "10M"],
-      [100000000, "100M"],
-      [1000000000, "1B"],
-    ])("formatRelativeNumber(%s) should return %s", (input, expected) => {
-      expect(formatRelativeNumber(input)).toBe(expected);
-    });
-
-    test.each([
-      [1234, 0, "1K"],
-      [1234, 1, "1.2K"],
-      [1234, 2, "1.23K"],
-      [1234567, 0, "1M"],
-      [1234567, 1, "1.2M"],
-      [1234567, 2, "1.23M"],
-    ])("formatRelativeNumber(%s, {precision: %s}) should return %s", (input, precision, expected) => {
-      expect(formatRelativeNumber(input, { precision })).toBe(expected);
-    });
-  });
-
-  describe("type safety and configuration validation", () => {
-    test("should handle undefined config", () => {
-      expect(formatRelativeNumber(1500, undefined)).toBe("1.5K");
-    });
-
-    test("should handle empty config object", () => {
-      expect(formatRelativeNumber(1500, {})).toBe("1.5K");
-    });
-
-    test("should handle partial config with precision only", () => {
-      expect(formatRelativeNumber(1234, { precision: 2 })).toBe("1.23K");
-    });
-
-    test("should handle partial config with lang only", () => {
-      expect(formatRelativeNumber(1500, { lang: "de-DE" })).toBe("1500");
-    });
-
-    test("should use defaults when config properties are undefined", () => {
-      expect(formatRelativeNumber(1500, { precision: undefined, lang: undefined })).toBe("1.5K");
-    });
-  });
-
-  describe("function behavior", () => {
-    test("should return string type", () => {
-      const result = formatRelativeNumber(1000);
-      expect(typeof result).toBe("string");
-    });
-
-    test("should handle consecutive calls consistently", () => {
-      const num = 1500;
-      const result1 = formatRelativeNumber(num);
-      const result2 = formatRelativeNumber(num);
-      expect(result1).toBe(result2);
-      expect(result1).toBe("1.5K");
-    });
-
-    test("should not mutate config object", () => {
-      const config = { precision: 2, lang: "en-US" };
-      const originalConfig = { ...config };
-      formatRelativeNumber(1000, config);
-      expect(config).toEqual(originalConfig);
-    });
-
-    test("should handle different input types that coerce to numbers", () => {
-      // These should work as TypeScript allows number type
-      expect(formatRelativeNumber(1000)).toBe("1K");
-      expect(formatRelativeNumber(1000.0)).toBe("1K");
-      expect(formatRelativeNumber(1e3)).toBe("1K");
-    });
-  });
-
-  describe("real world examples", () => {
-    test("should format social media metrics", () => {
-      expect(formatRelativeNumber(1200)).toBe("1.2K"); // followers
-      expect(formatRelativeNumber(15000)).toBe("15K"); // likes
-      expect(formatRelativeNumber(250000)).toBe("250K"); // views
-      expect(formatRelativeNumber(1800000)).toBe("1.8M"); // subscribers
-    });
-
-    test("should format financial numbers", () => {
-      expect(formatRelativeNumber(50000)).toBe("50K"); // salary
-      expect(formatRelativeNumber(125000)).toBe("125K"); // house price
-      expect(formatRelativeNumber(2500000)).toBe("2.5M"); // company value
-      expect(formatRelativeNumber(1200000000)).toBe("1.2B"); // market cap
-    });
-
-    test("should format file sizes (as numbers)", () => {
-      expect(formatRelativeNumber(1024)).toBe("1K"); // 1KB
-      expect(formatRelativeNumber(1048576)).toBe("1M"); // 1MB
-      expect(formatRelativeNumber(1073741824)).toBe("1.1B"); // 1GB
-    });
-
-    test("should format population numbers", () => {
-      expect(formatRelativeNumber(8500000)).toBe("8.5M"); // NYC population
-      expect(formatRelativeNumber(37000000)).toBe("37M"); // California population
-      expect(formatRelativeNumber(331000000)).toBe("331M"); // US population
-    });
-  });
-
-  describe("browser compatibility", () => {
-    test("should work with Intl.NumberFormat", () => {
-      // This ensures Intl.NumberFormat is available and working
-      expect(() => formatRelativeNumber(1000)).not.toThrow();
-      expect(formatRelativeNumber(1000)).toBeTruthy();
-    });
-
-    test("should handle various locales gracefully", () => {
-      const locales = ["en-US", "en-GB", "de-DE", "fr-FR", "es-ES", "it-IT", "pt-BR", "ru-RU", "zh-CN", "ja-JP"];
-
-      for (const locale of locales) {
-        expect(() => formatRelativeNumber(1500, { lang: locale })).not.toThrow();
-        const result = formatRelativeNumber(1500, { lang: locale });
-        expect(typeof result).toBe("string");
-        expect(result.length).toBeGreaterThan(0);
-      }
-    });
-
-    test("should handle invalid locale gracefully", () => {
-      // Invalid locales should fallback gracefully
-      expect(() => formatRelativeNumber(1500, { lang: "invalid-locale" })).not.toThrow();
-      const result = formatRelativeNumber(1500, { lang: "invalid-locale" });
-      expect(typeof result).toBe("string");
-    });
-  });
-});

package/tests/millisecondsToHMS.spec.ts

@@ -1,209 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { millisecondsToHMS } from "@/index";
-
-describe("millisecondsToHMS", () => {
-  describe("basic functionality", () => {
-    test("should convert seconds only (< 1 minute)", () => {
-      expect(millisecondsToHMS(5000)).toBe("5");
-      expect(millisecondsToHMS(30000)).toBe("30");
-      expect(millisecondsToHMS(59000)).toBe("59");
-    });
-
-    test("should convert minutes and seconds (< 1 hour)", () => {
-      expect(millisecondsToHMS(60000)).toBe("1:00");
-      expect(millisecondsToHMS(90000)).toBe("1:30");
-      expect(millisecondsToHMS(3599000)).toBe("59:59");
-    });
-
-    test("should convert hours, minutes and seconds (>= 1 hour)", () => {
-      expect(millisecondsToHMS(3600000)).toBe("1:00:00");
-      expect(millisecondsToHMS(3661000)).toBe("1:01:01");
-      expect(millisecondsToHMS(7200000)).toBe("2:00:00");
-    });
-
-    test("should handle zero milliseconds", () => {
-      expect(millisecondsToHMS(0)).toBe("0");
-    });
-  });
-
-  describe("formatting", () => {
-    test("should pad minutes with leading zero when hours present", () => {
-      expect(millisecondsToHMS(3660000)).toBe("1:01:00");
-      expect(millisecondsToHMS(3605000)).toBe("1:00:05");
-      expect(millisecondsToHMS(32400000 + 60000 + 5000)).toBe("9:01:05");
-    });
-
-    test("should pad seconds with leading zero when minutes present", () => {
-      expect(millisecondsToHMS(65000)).toBe("1:05");
-      expect(millisecondsToHMS(600000 + 1000)).toBe("10:01");
-      expect(millisecondsToHMS(3600000 + 60000 + 1000)).toBe("1:01:01");
-    });
-
-    test("should not pad single digits when no higher unit present", () => {
-      expect(millisecondsToHMS(1000)).toBe("1");
-      expect(millisecondsToHMS(5000)).toBe("5");
-      expect(millisecondsToHMS(9000)).toBe("9");
-    });
-
-    test("should handle double-digit values correctly", () => {
-      expect(millisecondsToHMS(10000)).toBe("10");
-      expect(millisecondsToHMS(600000 + 15000)).toBe("10:15");
-      expect(millisecondsToHMS(3600000 + 600000 + 15000)).toBe("1:10:15");
-    });
-  });
-
-  describe("edge cases", () => {
-    test("should handle milliseconds that don't divide evenly", () => {
-      expect(millisecondsToHMS(1500)).toBe("1"); // 1.5 seconds -> 1 second
-      expect(millisecondsToHMS(1999)).toBe("1"); // 1.999 seconds -> 1 second
-      expect(millisecondsToHMS(61500)).toBe("1:01"); // 61.5 seconds -> 1:01
-    });
-
-    test("should handle very small millisecond values", () => {
-      expect(millisecondsToHMS(1)).toBe("0");
-      expect(millisecondsToHMS(500)).toBe("0");
-      expect(millisecondsToHMS(999)).toBe("0");
-    });
-
-    test("should handle large hour values", () => {
-      expect(millisecondsToHMS(24 * 3600000)).toBe("24:00:00"); // 24 hours
-      expect(millisecondsToHMS(100 * 3600000)).toBe("100:00:00"); // 100 hours
-      expect(millisecondsToHMS(999 * 3600000)).toBe("999:00:00"); // 999 hours
-    });
-
-    test("should handle maximum safe integer values", () => {
-      const largeValue = 999999999000; // 999,999,999 seconds
-      const result = millisecondsToHMS(largeValue);
-      expect(typeof result).toBe("string");
-      expect(result).toMatch(/^\d+:\d{2}:\d{2}$/);
-    });
-  });
-
-  describe("mathematical precision", () => {
-    test("should floor milliseconds to seconds", () => {
-      expect(millisecondsToHMS(1001)).toBe("1");
-      expect(millisecondsToHMS(1999)).toBe("1");
-      expect(millisecondsToHMS(2001)).toBe("2");
-    });
-
-    test("should calculate minutes correctly", () => {
-      expect(millisecondsToHMS(60000)).toBe("1:00");
-      expect(millisecondsToHMS(119000)).toBe("1:59");
-      expect(millisecondsToHMS(120000)).toBe("2:00");
-    });
-
-    test("should calculate hours correctly", () => {
-      expect(millisecondsToHMS(3600000)).toBe("1:00:00");
-      expect(millisecondsToHMS(7199000)).toBe("1:59:59");
-      expect(millisecondsToHMS(7200000)).toBe("2:00:00");
-    });
-  });
-
-  describe("parametrized tests", () => {
-    test.each([
-      [0, "0"],
-      [1000, "1"],
-      [10000, "10"],
-      [60000, "1:00"],
-      [90000, "1:30"],
-      [3600000, "1:00:00"],
-      [3661000, "1:01:01"],
-      [7200000, "2:00:00"],
-      [86400000, "24:00:00"], // 1 day
-      [90061000, "25:01:01"], // 25 hours 1 minute 1 second
-    ])("millisecondsToHMS(%i) should return %s", (input, expected) => {
-      expect(millisecondsToHMS(input)).toBe(expected);
-    });
-  });
-
-  describe("real world examples", () => {
-    test("should handle common video durations", () => {
-      expect(millisecondsToHMS(30000)).toBe("30"); // 30 second video
-      expect(millisecondsToHMS(300000)).toBe("5:00"); // 5 minute video
-      expect(millisecondsToHMS(1800000)).toBe("30:00"); // 30 minute video
-      expect(millisecondsToHMS(5400000)).toBe("1:30:00"); // 1.5 hour movie
-      expect(millisecondsToHMS(7200000)).toBe("2:00:00"); // 2 hour movie
-    });
-
-    test("should handle common music track durations", () => {
-      expect(millisecondsToHMS(180000)).toBe("3:00"); // 3 minute song
-      expect(millisecondsToHMS(213000)).toBe("3:33"); // 3:33 song
-      expect(millisecondsToHMS(267000)).toBe("4:27"); // 4:27 song
-    });
-
-    test("should handle timer/stopwatch use cases", () => {
-      expect(millisecondsToHMS(5000)).toBe("5"); // 5 second countdown
-      expect(millisecondsToHMS(300000)).toBe("5:00"); // 5 minute timer
-      expect(millisecondsToHMS(900000)).toBe("15:00"); // 15 minute timer
-      expect(millisecondsToHMS(3600000)).toBe("1:00:00"); // 1 hour timer
-    });
-
-    test("should handle workout/exercise durations", () => {
-      expect(millisecondsToHMS(45000)).toBe("45"); // 45 second exercise
-      expect(millisecondsToHMS(90000)).toBe("1:30"); // 90 second rest
-      expect(millisecondsToHMS(1800000)).toBe("30:00"); // 30 minute workout
-    });
-  });
-
-  describe("type safety and consistency", () => {
-    test("should always return string type", () => {
-      expect(typeof millisecondsToHMS(0)).toBe("string");
-      expect(typeof millisecondsToHMS(1000)).toBe("string");
-      expect(typeof millisecondsToHMS(3600000)).toBe("string");
-    });
-
-    test("should handle consecutive calls consistently", () => {
-      const testValue = 3661000;
-      const result1 = millisecondsToHMS(testValue);
-      const result2 = millisecondsToHMS(testValue);
-      expect(result1).toBe(result2);
-      expect(result1).toBe("1:01:01");
-    });
-
-    test("should not mutate input or have side effects", () => {
-      const originalValue = 3661000;
-      const valueCopy = originalValue;
-      const result = millisecondsToHMS(originalValue);
-      expect(originalValue).toBe(valueCopy);
-      expect(result).toBe("1:01:01");
-    });
-  });
-
-  describe("format validation", () => {
-    test("seconds only format should be numeric string", () => {
-      const result = millisecondsToHMS(5000);
-      expect(result).toMatch(/^\d+$/);
-    });
-
-    test("minutes format should be M:SS", () => {
-      const result = millisecondsToHMS(90000);
-      expect(result).toMatch(/^\d+:\d{2}$/);
-    });
-
-    test("hours format should be H:MM:SS", () => {
-      const result = millisecondsToHMS(3661000);
-      expect(result).toMatch(/^\d+:\d{2}:\d{2}$/);
-    });
-
-    test("should never return negative values", () => {
-      // Even though function doesn't handle negative input explicitly,
-      // we test current behavior
-      const results = [
-        millisecondsToHMS(0),
-        millisecondsToHMS(1000),
-        millisecondsToHMS(60000),
-        millisecondsToHMS(3600000),
-      ];
-
-      results.forEach((result) => {
-        expect(result).not.toMatch(/-/);
-      });
-    });
-
-    test("should maintain consistent padding", () => {
-      expect(millisecondsToHMS(3605000)).toBe("1:00:05"); // H:MM:SS
-      expect(millisecondsToHMS(3065000)).toBe("51:05"); // M:SS when < 1 hour
-      expect(millisecondsToHMS(65000)).toBe("1:05"); // M:SS
-    });
-  });
-});