@bash-app/bash-common 30.247.0 → 30.254.0

package/src/utils/__tests__/luxonUtils.test.ts

@@ -0,0 +1,171 @@
+import { DayOfWeek } from "@prisma/client";
+import { DateTime } from "luxon";
+import { describe, expect, test } from "@jest/globals";
+import {
+  dateRangeDurationMatch,
+  dateTimeDiffHours,
+  dateTimeFormat,
+  dateTimeFormatDateRange,
+  dateTimeFromDate,
+  dateTimeFromDayTime,
+  dateTimeRangeCrossesMidnight,
+  dateTimeToTimeComponents,
+  dateTimeWithinRange,
+  dayOfWeekFromIdx,
+  dayOfWeekGetIdx,
+  filterConflictingIntervals,
+  luxonDateRangeSort,
+  mergeCrossDayHours,
+  utcOffsetMinutesToTimezone,
+} from "../luxonUtils.js";
+
+describe("luxonUtils", () => {
+  describe("day of week helpers", () => {
+    test("dayOfWeekGetIdx accepts enum and numeric index", () => {
+      expect(dayOfWeekGetIdx(DayOfWeek.Wednesday)).toBe(3);
+      expect(dayOfWeekGetIdx(5)).toBe(5);
+    });
+
+    test("dayOfWeekFromIdx accepts index and enum passthrough", () => {
+      expect(dayOfWeekFromIdx(4)).toBe(DayOfWeek.Thursday);
+      expect(dayOfWeekFromIdx(DayOfWeek.Friday)).toBe(DayOfWeek.Friday);
+    });
+
+    test("dateTimeFromDayTime builds weekday time in zone", () => {
+      const dt = dateTimeFromDayTime(DayOfWeek.Monday, 14, 30, "UTC");
+      expect(dt.weekday).toBe(1);
+      expect(dt.hour).toBe(14);
+      expect(dt.minute).toBe(30);
+    });
+  });
+
+  describe("dateTimeFromDate and formatting", () => {
+    test("dateTimeFromDate parses ISO string", () => {
+      const dt = dateTimeFromDate("2024-03-15T18:00:00.000Z", "UTC");
+      expect(dt.year).toBe(2024);
+      expect(dt.month).toBe(3);
+      expect(dt.day).toBe(15);
+    });
+
+    test("dateTimeToTimeComponents extracts hour and minute", () => {
+      const dt = DateTime.fromObject({ hour: 9, minute: 15 }, { zone: "UTC" });
+      expect(dateTimeToTimeComponents(dt)).toEqual({ hour: 9, minute: 15 });
+    });
+
+    test("dateTimeFormat returns empty string for nullish", () => {
+      expect(dateTimeFormat(null)).toBe("");
+      expect(dateTimeFormat(undefined)).toBe("");
+    });
+  });
+
+  describe("range helpers", () => {
+    const start = DateTime.fromISO("2024-01-01T10:00:00", { zone: "UTC" });
+    const end = DateTime.fromISO("2024-01-01T18:00:00", { zone: "UTC" });
+    const range = { start, end };
+
+    test("dateTimeWithinRange detects containment", () => {
+      const inside = DateTime.fromISO("2024-01-01T12:00:00", { zone: "UTC" });
+      const outside = DateTime.fromISO("2024-01-01T19:00:00", { zone: "UTC" });
+      expect(dateTimeWithinRange(inside, range)).toBe(true);
+      expect(dateTimeWithinRange(outside, range)).toBe(false);
+    });
+
+    test("dateRangeDurationMatch compares durations within tolerance", () => {
+      const lhs = {
+        start: DateTime.fromISO("2024-01-01T10:00:00", { zone: "UTC" }),
+        end: DateTime.fromISO("2024-01-01T12:00:00", { zone: "UTC" }),
+      };
+      const rhs = {
+        start: DateTime.fromISO("2024-02-01T10:00:00", { zone: "UTC" }),
+        end: DateTime.fromISO("2024-02-01T12:00:30", { zone: "UTC" }),
+      };
+      expect(dateRangeDurationMatch(lhs, rhs, 60)).toBe(true);
+    });
+
+    test("dateTimeFormatDateRange uses time-only end on same day", () => {
+      const sameDayStart = DateTime.fromISO("2024-06-01T18:00:00", { zone: "UTC" });
+      const sameDayEnd = DateTime.fromISO("2024-06-01T22:00:00", { zone: "UTC" });
+      const formatted = dateTimeFormatDateRange(sameDayStart, sameDayEnd);
+      expect(formatted).toContain(" to ");
+      expect(formatted.split(" to ")[1]).toMatch(/\d/);
+    });
+
+    test("dateTimeRangeCrossesMidnight detects overnight ranges", () => {
+      const overnight = {
+        start: DateTime.fromObject({ hour: 22, minute: 0 }, { zone: "UTC" }),
+        end: DateTime.fromObject({ hour: 2, minute: 0 }, { zone: "UTC" }),
+      };
+      const sameDay = {
+        start: DateTime.fromObject({ hour: 9, minute: 0 }, { zone: "UTC" }),
+        end: DateTime.fromObject({ hour: 17, minute: 0 }, { zone: "UTC" }),
+      };
+      expect(dateTimeRangeCrossesMidnight(overnight)).toBe(true);
+      expect(dateTimeRangeCrossesMidnight(sameDay)).toBe(false);
+    });
+  });
+
+  describe("mergeCrossDayHours", () => {
+    test("merges ranges separated by one minute or less", () => {
+      const base = DateTime.fromObject({ hour: 9 }, { zone: "UTC" });
+      const merged = mergeCrossDayHours([
+        { start: base, end: base.plus({ hours: 2 }) },
+        { start: base.plus({ hours: 2, minutes: 1 }), end: base.plus({ hours: 4 }) },
+      ]);
+      expect(merged).toHaveLength(1);
+      expect(merged[0].end.hour).toBe(13);
+    });
+
+    test("keeps separate ranges when gap exceeds one minute", () => {
+      const base = DateTime.fromObject({ hour: 9 }, { zone: "UTC" });
+      const merged = mergeCrossDayHours([
+        { start: base, end: base.plus({ hours: 1 }) },
+        { start: base.plus({ hours: 2 }), end: base.plus({ hours: 3 }) },
+      ]);
+      expect(merged).toHaveLength(2);
+    });
+  });
+
+  describe("filterConflictingIntervals", () => {
+    test("subtracts blocked hours from available hours", () => {
+      const day = DateTime.fromObject({ hour: 8 }, { zone: "UTC" });
+      const available = [{ start: day, end: day.plus({ hours: 8 }) }];
+      const blocked = [
+        {
+          start: day.plus({ hours: 2 }),
+          end: day.plus({ hours: 3 }),
+        },
+      ];
+      const remaining = filterConflictingIntervals(available, blocked);
+      expect(remaining.length).toBeGreaterThan(0);
+      expect(remaining.every((r) => r.end > r.start)).toBe(true);
+    });
+  });
+
+  describe("utcOffsetMinutesToTimezone", () => {
+    test("formats positive and negative offsets", () => {
+      expect(utcOffsetMinutesToTimezone(300)).toBe("UTC+05:00");
+      expect(utcOffsetMinutesToTimezone(-480)).toBe("UTC-08:00");
+    });
+  });
+
+  describe("dateTimeDiffHours", () => {
+    test("returns 0 when start or end missing", () => {
+      expect(dateTimeDiffHours(null, DateTime.now())).toBe(0);
+      expect(dateTimeDiffHours(DateTime.now(), null)).toBe(0);
+    });
+  });
+
+  describe("luxonDateRangeSort", () => {
+    test("sorts ranges by start time ascending", () => {
+      const later = {
+        start: DateTime.fromISO("2024-01-02T10:00:00", { zone: "UTC" }),
+        end: DateTime.fromISO("2024-01-02T12:00:00", { zone: "UTC" }),
+      };
+      const earlier = {
+        start: DateTime.fromISO("2024-01-01T10:00:00", { zone: "UTC" }),
+        end: DateTime.fromISO("2024-01-01T12:00:00", { zone: "UTC" }),
+      };
+      expect(luxonDateRangeSort([later, earlier])).toEqual([earlier, later]);
+    });
+  });
+});

package/src/utils/__tests__/mathUtils.test.ts

@@ -0,0 +1,30 @@
+/**
+ * Tests for numeric rounding helpers.
+ */
+
+import { describe, expect, test } from "@jest/globals";
+import { roundToNearestDivisor } from "../mathUtils.js";
+
+describe("mathUtils", () => {
+  describe("roundToNearestDivisor", () => {
+    test("rounds to nearest cent (divisor 100)", () => {
+      expect(roundToNearestDivisor(12.345, 100)).toBe(12.35);
+      expect(roundToNearestDivisor(12.344, 100)).toBe(12.34);
+    });
+
+    test("rounds to nearest tenth (divisor 10)", () => {
+      expect(roundToNearestDivisor(3.14, 10)).toBe(3.1);
+      expect(roundToNearestDivisor(3.16, 10)).toBe(3.2);
+    });
+
+    test("returns whole numbers unchanged when divisor is 1", () => {
+      expect(roundToNearestDivisor(42, 1)).toBe(42);
+      expect(roundToNearestDivisor(42.6, 1)).toBe(43);
+    });
+
+    test("handles zero and negative values", () => {
+      expect(roundToNearestDivisor(0, 100)).toBe(0);
+      expect(roundToNearestDivisor(-1.235, 100)).toBe(-1.24);
+    });
+  });
+});

package/src/utils/__tests__/objUtils.test.ts

@@ -0,0 +1,48 @@
+/**
+ * Tests for object type guards and deep merge.
+ */
+
+import { describe, expect, test } from "@jest/globals";
+import { isObject, deepMerge } from "../objUtils.js";
+
+describe("objUtils", () => {
+  describe("isObject", () => {
+    test("returns true for plain objects", () => {
+      expect(isObject({ a: 1 })).toBe(true);
+      expect(isObject(Object.create(null))).toBe(true);
+    });
+
+    test("returns false for null, arrays, dates, and primitives", () => {
+      expect(isObject(null)).toBe(false);
+      expect(isObject([1, 2])).toBe(false);
+      expect(isObject(new Date())).toBe(false);
+      expect(isObject("string")).toBe(false);
+      expect(isObject(42)).toBe(false);
+    });
+  });
+
+  describe("deepMerge", () => {
+    test("overwrites scalar values from source", () => {
+      expect(deepMerge({ a: 1, b: 2 }, { b: 99 })).toEqual({ a: 1, b: 99 });
+    });
+
+    test("recursively merges nested objects", () => {
+      expect(deepMerge({ nested: { x: 1, y: 2 } }, { nested: { y: 3, z: 4 } })).toEqual({
+        nested: { x: 1, y: 3, z: 4 },
+      });
+    });
+
+    test("concatenates arrays when mergeArrays is true", () => {
+      expect(deepMerge({ tags: ["a"] }, { tags: ["b"] }, true)).toEqual({ tags: ["a", "b"] });
+    });
+
+    test("replaces arrays by default", () => {
+      expect(deepMerge({ tags: ["a"] }, { tags: ["b"] })).toEqual({ tags: ["b"] });
+    });
+
+    test("handles null/undefined target or source", () => {
+      expect(deepMerge(null, { a: 1 })).toEqual({ a: 1 });
+      expect(deepMerge({ a: 1 }, null)).toEqual({ a: 1 });
+    });
+  });
+});

package/src/utils/__tests__/paymentUtils.test.ts

@@ -16,6 +16,7 @@ import {
   calculateTotalBashPoints,
   calculateStripeDonationFee,
   calculateServiceFeeWithMembershipDiscount,
+  calculatePartnerFeeWithMembershipDiscount,
   calculateBashPlatformFeeCents,
   splitBashPlatformFeeForTicketCheckout,
   computeTicketApplicationFeeAmountCents,
@@ -24,7 +25,9 @@ import {
   getBashPassMonthlyCapRemaining,
   higherBashPassTier,
   membershipGrantsBashPassTier,
+  VENUE_PRICING_PLAN_DATA,
 } from "../paymentUtils.js";
+import { VenuePricingPlan } from "@prisma/client";
 
 describe("PaymentUtils - Core Functions", () => {
   describe("Currency Conversion", () => {
@@ -337,6 +340,62 @@ describe("PaymentUtils - Core Functions", () => {
     });
   });
 
+  describe("Partner fee with membership discount", () => {
+    test("calculatePartnerFeeWithMembershipDiscount scales with amount", () => {
+      const small = calculatePartnerFeeWithMembershipDiscount(1000, MembershipTier.Basic);
+      const large = calculatePartnerFeeWithMembershipDiscount(100000, MembershipTier.Basic);
+      expect(large).toBeGreaterThan(small);
+    });
+
+    test("calculatePartnerFeeWithMembershipDiscount defaults to Basic tier", () => {
+      const withTier = calculatePartnerFeeWithMembershipDiscount(5000, MembershipTier.Pro);
+      const defaulted = calculatePartnerFeeWithMembershipDiscount(5000, null);
+      expect(typeof withTier).toBe("number");
+      expect(typeof defaulted).toBe("number");
+    });
+  });
+
+  describe("VENUE_PRICING_PLAN_DATA", () => {
+    test("Percentage plan uses pay-per-booking copy and fee", () => {
+      const plan = VENUE_PRICING_PLAN_DATA[VenuePricingPlan.Percentage];
+      expect(plan.name).toBe("Pay per booking");
+      expect(plan.percentageFee).toBeGreaterThan(0);
+      expect(plan.monthlyFee).toBe(0);
+    });
+
+    test("Subscription plan is flat monthly with no percentage fee", () => {
+      const plan = VENUE_PRICING_PLAN_DATA[VenuePricingPlan.Subscription];
+      expect(plan.monthlyFee).toBe(100);
+      expect(plan.percentageFee).toBe(0);
+    });
+  });
+
+  describe("splitBashPlatformFeeForTicketCheckout edge cases", () => {
+    test("returns zeros when platform fee disabled", () => {
+      expect(
+        splitBashPlatformFeeForTicketCheckout({
+          grossCents: 10000,
+          platformFeeEnabled: false,
+          platformFeeRate: 0.03,
+          feeHandling: "GuestPays",
+          bashPassWaivesGuestFee: false,
+        })
+      ).toEqual({ totalPlatformCents: 0, guestPlatformLineCents: 0 });
+    });
+
+    test("defaults feeHandling to HostAbsorbs", () => {
+      expect(
+        splitBashPlatformFeeForTicketCheckout({
+          grossCents: 10000,
+          platformFeeEnabled: true,
+          platformFeeRate: 0.03,
+          feeHandling: null,
+          bashPassWaivesGuestFee: false,
+        })
+      ).toEqual({ totalPlatformCents: 300, guestPlatformLineCents: 0 });
+    });
+  });
+
   describe("BashPass tier and monthly cap", () => {
     const future = new Date(Date.now() + 86400000 * 30);
     const past = new Date(Date.now() - 86400000);

package/src/utils/__tests__/qrCodeUtils.test.ts

@@ -18,12 +18,18 @@
  *
  * Bugs in any of these route door-scanners to the wrong page (= entry chaos).
  */
+import QRCode from "qrcode";
+
 import {
   bashEventPrismaCheckoutQrCodeUrl,
   bashEventQrCodeUrl,
   createQrCodeImage,
 } from "../qrCodeUtils.js";
 
+jest.mock("qrcode", () => ({
+  toDataURL: jest.fn(),
+}));
+
 // ============================================================================
 // bashEventPrismaCheckoutQrCodeUrl — checkout-id deep link
 // ============================================================================
@@ -120,22 +126,43 @@ describe("bashEventQrCodeUrl", () => {
 // ============================================================================
 
 describe("createQrCodeImage", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
   it("returns a base64-encoded PNG data URL", async () => {
+    const mockDataUrl =
+      "data:image/png;base64," +
+      "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==".repeat(
+        3
+      );
+    (QRCode.toDataURL as jest.Mock).mockResolvedValue(mockDataUrl);
+
     const dataUrl = await createQrCodeImage(
       "https://bash.app/ticket-details/evt_1/ticket/abc"
     );
     expect(dataUrl).toMatch(/^data:image\/png;base64,/);
-    // Sanity: a real QR image will have *meaningful* base64 length, not a few bytes.
     expect(dataUrl.length).toBeGreaterThan(200);
+    expect(QRCode.toDataURL).toHaveBeenCalledWith(
+      "https://bash.app/ticket-details/evt_1/ticket/abc",
+      { errorCorrectionLevel: "high" }
+    );
   });
 
   it("produces a deterministic PNG for the same input (no nonce / timestamp leakage)", async () => {
+    const mockDataUrl = "data:image/png;base64,same-payload";
+    (QRCode.toDataURL as jest.Mock).mockResolvedValue(mockDataUrl);
+
     const a = await createQrCodeImage("ticket://abc");
     const b = await createQrCodeImage("ticket://abc");
     expect(a).toBe(b);
   });
 
   it("produces DIFFERENT output for different payloads", async () => {
+    (QRCode.toDataURL as jest.Mock)
+      .mockResolvedValueOnce("data:image/png;base64,abc")
+      .mockResolvedValueOnce("data:image/png;base64,xyz");
+
     const a = await createQrCodeImage("ticket://abc");
     const b = await createQrCodeImage("ticket://xyz");
     expect(a).not.toBe(b);

package/src/utils/__tests__/reviewUtils.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  calculateAverageRating,
+  generateReviewStats,
+  formatRatingWithStars,
+  isEligibleToReview,
+} from "../reviewUtils.js";
+import type { Review } from "../../definitions.js";
+
+const reviews: Review[] = [
+  { rating: 5, id: "1" } as Review,
+  { rating: 4, id: "2" } as Review,
+  { rating: 3, id: "3" } as Review,
+];
+
+describe("reviewUtils", () => {
+  describe("calculateAverageRating", () => {
+    test("returns 0 for empty list", () => {
+      expect(calculateAverageRating([])).toBe(0);
+    });
+
+    test("averages ratings to one decimal", () => {
+      expect(calculateAverageRating(reviews)).toBe(4);
+    });
+  });
+
+  describe("generateReviewStats", () => {
+    test("builds distribution and totals", () => {
+      expect(generateReviewStats(reviews)).toEqual({
+        averageRating: 4,
+        totalRatings: 3,
+        ratings: { 1: 0, 2: 0, 3: 1, 4: 1, 5: 1 },
+      });
+    });
+
+    test("ignores out-of-range ratings", () => {
+      const mixed = [{ rating: 6, id: "x" } as Review, { rating: 0, id: "y" } as Review];
+      expect(generateReviewStats(mixed).ratings).toEqual({ 1: 0, 2: 0, 3: 0, 4: 0, 5: 0 });
+    });
+  });
+
+  describe("formatRatingWithStars", () => {
+    test("includes full stars and half star", () => {
+      expect(formatRatingWithStars(4.5)).toBe("4.5 ★★★★½");
+    });
+
+    test("rounds down fractional stars below 0.5", () => {
+      expect(formatRatingWithStars(3.2)).toBe("3.2 ★★★");
+    });
+  });
+
+  describe("isEligibleToReview", () => {
+    test("allows attendee who has not reviewed and is not the host", () => {
+      expect(isEligibleToReview("user-1", "event-1", "host-1", [], ["event-1"])).toBe(true);
+    });
+
+    test("blocks host, non-attendees, and duplicate reviews", () => {
+      expect(isEligibleToReview("host-1", "event-1", "host-1", [], ["event-1"])).toBe(false);
+      expect(isEligibleToReview("user-1", "event-1", "host-1", [], [])).toBe(false);
+      expect(isEligibleToReview("user-1", "event-1", "host-1", ["event-1"], ["event-1"])).toBe(
+        false
+      );
+    });
+  });
+});

package/src/utils/__tests__/slugUtils.test.ts

@@ -0,0 +1,143 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  BASH_DETAIL_URL,
+  BASH_EVENT_WIZARD_HOW_MAJOR_STEP,
+  BASH_EVENT_WIZARD_HOW_SUBSTEP_PAYOUT,
+  BASH_EVENT_WIZARD_PATH_PREFIX,
+} from "../../definitions.js";
+import {
+  generateSlug,
+  generateUniqueSlug,
+  generateBashDetailUrl,
+  getPublicBashDetailPath,
+  getBashEventWizardStepPath,
+  getBashEventWizardPayoutStepPath,
+  parseBashUrlParams,
+  validateSlug,
+} from "../slugUtils.js";
+
+describe("generateSlug", () => {
+  test("lowercases and slugifies a title", () => {
+    expect(generateSlug("Summer Bash 2026!")).toBe("summer-bash-2026");
+  });
+
+  test("removes special characters", () => {
+    expect(generateSlug("Hello *World*")).toBe("hello-world");
+  });
+
+  test("handles empty string", () => {
+    expect(generateSlug("")).toBe("");
+  });
+});
+
+describe("generateUniqueSlug", () => {
+  test("returns base slug when available", async () => {
+    const checkSlugExists = async () => false;
+    await expect(generateUniqueSlug("My Event", checkSlugExists)).resolves.toBe("my-event");
+  });
+
+  test("appends counter when slug exists", async () => {
+    const taken = new Set(["my-event", "my-event-1"]);
+    const checkSlugExists = async (slug: string) => taken.has(slug);
+    await expect(generateUniqueSlug("My Event", checkSlugExists)).resolves.toBe("my-event-2");
+  });
+
+  test("passes excludeId to checkSlugExists", async () => {
+    const calls: Array<{ slug: string; excludeId?: string }> = [];
+    const checkSlugExists = async (slug: string, excludeId?: string) => {
+      calls.push({ slug, excludeId });
+      return false;
+    };
+    await generateUniqueSlug("My Event", checkSlugExists, "event-123");
+    expect(calls).toEqual([{ slug: "my-event", excludeId: "event-123" }]);
+  });
+});
+
+describe("generateBashDetailUrl", () => {
+  test("builds id-slug path", () => {
+    expect(generateBashDetailUrl("abc123", "summer-bash")).toBe("/bash/abc123-summer-bash");
+  });
+});
+
+describe("getPublicBashDetailPath", () => {
+  test("uses slug path when slug is present", () => {
+    expect(getPublicBashDetailPath("abc123", "summer-bash")).toBe(
+      "/bash/abc123-summer-bash"
+    );
+  });
+
+  test("trims slug before use", () => {
+    expect(getPublicBashDetailPath("abc123", "  summer-bash  ")).toBe(
+      "/bash/abc123-summer-bash"
+    );
+  });
+
+  test("falls back to id-only legacy path when slug missing", () => {
+    expect(getPublicBashDetailPath("abc123", null)).toBe(`${BASH_DETAIL_URL}/abc123`);
+    expect(getPublicBashDetailPath("abc123", undefined)).toBe(`${BASH_DETAIL_URL}/abc123`);
+    expect(getPublicBashDetailPath("abc123", "   ")).toBe(`${BASH_DETAIL_URL}/abc123`);
+  });
+});
+
+describe("getBashEventWizardStepPath", () => {
+  test("builds wizard step path", () => {
+    expect(getBashEventWizardStepPath("evt-1", 3, 2)).toBe(
+      `${BASH_EVENT_WIZARD_PATH_PREFIX}/evt-1/3/2`
+    );
+  });
+});
+
+describe("getBashEventWizardPayoutStepPath", () => {
+  test("returns How → Payout step path", () => {
+    expect(getBashEventWizardPayoutStepPath("evt-1")).toBe(
+      `${BASH_EVENT_WIZARD_PATH_PREFIX}/evt-1/${BASH_EVENT_WIZARD_HOW_MAJOR_STEP}/${BASH_EVENT_WIZARD_HOW_SUBSTEP_PAYOUT}`
+    );
+  });
+});
+
+describe("parseBashUrlParams", () => {
+  test("parses id-slug format", () => {
+    expect(parseBashUrlParams("abc123-summer-bash")).toEqual({
+      id: "abc123",
+      slug: "summer-bash",
+    });
+  });
+
+  test("parses id-only legacy format", () => {
+    expect(parseBashUrlParams("abc123")).toEqual({ id: "abc123", slug: null });
+  });
+
+  test("returns null for empty param", () => {
+    expect(parseBashUrlParams("")).toBeNull();
+  });
+
+  test("returns null when id portion is empty", () => {
+    expect(parseBashUrlParams("-slug-only")).toBeNull();
+  });
+
+  test("returns slug null when trailing dash has no slug", () => {
+    expect(parseBashUrlParams("abc123-")).toEqual({ id: "abc123", slug: null });
+  });
+
+  test("uses first dash as separator only", () => {
+    expect(parseBashUrlParams("abc-my-cool-event")).toEqual({
+      id: "abc",
+      slug: "my-cool-event",
+    });
+  });
+});
+
+describe("validateSlug", () => {
+  test.each([
+    ["valid-slug", true],
+    ["abc123", true],
+    ["a-b-c", true],
+    ["UPPERCASE", false],
+    ["has spaces", false],
+    ["has_underscore", false],
+    ["special!", false],
+    ["", false],
+  ])("validateSlug(%s) → %s", (slug, expected) => {
+    expect(validateSlug(slug)).toBe(expected);
+  });
+});

package/src/utils/__tests__/sortUtils.test.ts

@@ -0,0 +1,33 @@
+/**
+ * Tests for tier sort ordering.
+ */
+
+import { describe, expect, test } from "@jest/globals";
+import { sortTiers } from "../sortUtils.js";
+
+describe("sortUtils", () => {
+  describe("sortTiers", () => {
+    test("returns 0 when sortOrder matches", () => {
+      expect(sortTiers({ sortOrder: 2 }, { sortOrder: 2 })).toBe(0);
+    });
+
+    test("sorts by sortOrder ascending", () => {
+      expect(sortTiers({ sortOrder: 1 }, { sortOrder: 3 })).toBeLessThan(0);
+      expect(sortTiers({ sortOrder: 5 }, { sortOrder: 2 })).toBeGreaterThan(0);
+    });
+
+    test("falls back to price when sortOrder absent", () => {
+      expect(sortTiers({ price: 10 }, { price: 20 })).toBeLessThan(0);
+      expect(sortTiers({ price: 20 }, { price: 10 })).toBeGreaterThan(0);
+    });
+
+    test("empty values sort before defined values", () => {
+      expect(sortTiers({}, { sortOrder: 1 })).toBeLessThan(0);
+      expect(sortTiers({ sortOrder: 1 }, {})).toBeGreaterThan(0);
+    });
+
+    test("returns 0 when both tiers lack comparable fields", () => {
+      expect(sortTiers({}, {})).toBe(0);
+    });
+  });
+});

package/src/utils/__tests__/stringUtils.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "@jest/globals";
+import { formatString } from "../stringUtils.js";
+
+describe("formatString", () => {
+  test("replaces placeholders with string values", () => {
+    expect(formatString("Hello ${name}!", { name: "World" })).toBe("Hello World!");
+  });
+
+  test("replaces placeholders with numeric values", () => {
+    expect(formatString("Count: ${count}", { count: 42 })).toBe("Count: 42");
+  });
+
+  test("replaces multiple placeholders", () => {
+    expect(
+      formatString("${greeting}, ${name}!", { greeting: "Hi", name: "Alex" })
+    ).toBe("Hi, Alex!");
+  });
+
+  test("uses empty string for missing keys", () => {
+    expect(formatString("Hello ${name}!", {})).toBe("Hello !");
+  });
+
+  test("leaves text without placeholders unchanged", () => {
+    expect(formatString("No placeholders here", { unused: "x" })).toBe(
+      "No placeholders here"
+    );
+  });
+
+  test("handles empty template", () => {
+    expect(formatString("", { key: "value" })).toBe("");
+  });
+
+  test("only matches word-character keys", () => {
+    expect(formatString("${key_1} ${key2}", { key_1: "a", key2: "b" })).toBe("a b");
+    expect(formatString("${key-name}", {})).toBe("${key-name}");
+  });
+});