@hobenakicoffee/libraries 3.4.2 → 4.1.0

package/src/utils/check-moderation.test.ts

@@ -1,321 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from "bun:test";
-import type OpenAI from "openai";
-import { checkModeration } from "./check-moderation";
-
-describe("checkModeration", () => {
-  let mockOpenAiClient: OpenAI;
-  let mockModerations: any;
-
-  beforeEach(() => {
-    mockModerations = {
-      create: mock(async () => ({
-        results: [
-          {
-            flagged: false,
-            categories: {},
-          },
-        ],
-      })),
-    };
-
-    mockOpenAiClient = {
-      moderations: mockModerations,
-    } as unknown as OpenAI;
-  });
-
-  test("returns OpenAI result when no profanity detected", async () => {
-    mockModerations.create = mock(async () => ({
-      results: [
-        {
-          flagged: true,
-          categories: {
-            hate: true,
-            sexual: false,
-          },
-        },
-      ],
-    }));
-
-    const result = await checkModeration(mockOpenAiClient, "clean text");
-
-    expect(result.flagged).toBe(true);
-    expect(result.source).toBe("openai");
-    expect(result.categories?.hate).toBe(true);
-    expect(result.categories?.sexual).toBe(false);
-    expect(result.error).toBeNull();
-  });
-
-  test("returns flagged false when OpenAI approves text", async () => {
-    mockModerations.create = mock(async () => ({
-      results: [
-        {
-          flagged: false,
-          categories: {},
-        },
-      ],
-    }));
-
-    const result = await checkModeration(mockOpenAiClient, "safe text");
-
-    expect(result.flagged).toBe(false);
-    expect(result.source).toBe("openai");
-    expect(result.error).toBeNull();
-  });
-
-  test("calls OpenAI moderations API with correct model", async () => {
-    mockModerations.create = mock(async () => ({
-      results: [
-        {
-          flagged: false,
-          categories: {},
-        },
-      ],
-    }));
-
-    const testText = "test content";
-    await checkModeration(mockOpenAiClient, testText);
-
-    expect(mockModerations.create).toHaveBeenCalledWith({
-      model: "omni-moderation-latest",
-      input: testText,
-    });
-  });
-
-  test("returns error object when OpenAI API throws", async () => {
-    const testError = new Error("API Error");
-    mockModerations.create = mock(() => {
-      throw testError;
-    });
-
-    const result = await checkModeration(mockOpenAiClient, "test");
-
-    expect(result.flagged).toBe(false);
-    expect(result.categories).toBeNull();
-    expect(result.error).toBe(testError);
-    expect(result.source).toBeNull();
-  });
-
-  test("returns error with stack trace when API fails", async () => {
-    const testError = new Error("Network error");
-    mockModerations.create = mock(() => {
-      throw testError;
-    });
-
-    const result = await checkModeration(mockOpenAiClient, "test");
-
-    expect(typeof result.error).toBe("object");
-    expect(result.source).toBeNull();
-  });
-
-  test("returns proper result structure for OpenAI case", async () => {
-    mockModerations.create = mock(async () => ({
-      results: [
-        {
-          flagged: false,
-          categories: {},
-        },
-      ],
-    }));
-
-    const result = await checkModeration(mockOpenAiClient, "test");
-
-    expect(result).toHaveProperty("flagged");
-    expect(result).toHaveProperty("categories");
-    expect(result).toHaveProperty("error");
-    expect(result).toHaveProperty("source");
-  });
-
-  test("returns proper result structure for error case", async () => {
-    mockModerations.create = mock(() => {
-      throw new Error("Test error");
-    });
-
-    const result = await checkModeration(mockOpenAiClient, "test");
-
-    expect(result).toHaveProperty("flagged");
-    expect(result).toHaveProperty("categories");
-    expect(result).toHaveProperty("error");
-    expect(result).toHaveProperty("source");
-  });
-
-  test("handles OpenAI result with null categories", async () => {
-    mockModerations.create = mock(async () => ({
-      results: [
-        {
-          flagged: false,
-          categories: null,
-        },
-      ],
-    }));
-
-    const result = await checkModeration(mockOpenAiClient, "test");
-
-    expect(result.categories).toBeNull();
-    expect(result.source).toBe("openai");
-  });
-
-  test("handles empty OpenAI results array gracefully", async () => {
-    mockModerations.create = mock(async () => ({
-      results: [],
-    }));
-
-    const result = await checkModeration(mockOpenAiClient, "test");
-
-    expect(result.flagged).toBe(false);
-    expect(result.categories).toBeNull();
-    expect(result.source).toBe("openai");
-  });
-
-  test("handles empty text input", async () => {
-    mockModerations.create = mock(async () => ({
-      results: [
-        {
-          flagged: false,
-          categories: {},
-        },
-      ],
-    }));
-
-    const result = await checkModeration(mockOpenAiClient, "");
-
-    expect(result.source).toBe("openai");
-    expect(result.error).toBeNull();
-  });
-
-  test("handles special characters in text", async () => {
-    mockModerations.create = mock(async () => ({
-      results: [
-        {
-          flagged: false,
-          categories: {},
-        },
-      ],
-    }));
-
-    const result = await checkModeration(mockOpenAiClient, "test!@#$%^&*()");
-
-    expect(result.source).toBe("openai");
-    expect(result.error).toBeNull();
-  });
-
-  test("handles very long text", async () => {
-    mockModerations.create = mock(async () => ({
-      results: [
-        {
-          flagged: false,
-          categories: {},
-        },
-      ],
-    }));
-
-    const longText = "test ".repeat(10_000);
-    const result = await checkModeration(mockOpenAiClient, longText);
-
-    expect(result.source).toBe("openai");
-    expect(result.error).toBeNull();
-  });
-
-  test("returns source as null on error", async () => {
-    mockModerations.create = mock(() => {
-      throw new Error("API Error");
-    });
-
-    const result = await checkModeration(mockOpenAiClient, "test");
-
-    expect(result.source).toBeNull();
-  });
-
-  test("returns flagged as false when error occurs", async () => {
-    mockModerations.create = mock(() => {
-      throw new Error("API Error");
-    });
-
-    const result = await checkModeration(mockOpenAiClient, "test");
-
-    expect(result.flagged).toBe(false);
-  });
-
-  test("handles multiple category flags", async () => {
-    mockModerations.create = mock(async () => ({
-      results: [
-        {
-          flagged: true,
-          categories: {
-            hate: true,
-            sexual: true,
-            violence: true,
-            harassment: false,
-          },
-        },
-      ],
-    }));
-
-    const result = await checkModeration(mockOpenAiClient, "test");
-
-    expect(result.flagged).toBe(true);
-    expect(result.categories?.hate).toBe(true);
-    expect(result.categories?.sexual).toBe(true);
-    expect(result.categories?.violence).toBe(true);
-  });
-
-  test("passes input to OpenAI exactly as provided", async () => {
-    mockModerations.create = mock(async () => ({
-      results: [
-        {
-          flagged: false,
-          categories: {},
-        },
-      ],
-    }));
-
-    const customText = "Custom text with special @#$ chars";
-    await checkModeration(mockOpenAiClient, customText);
-
-    const callArgs = mockModerations.create.mock.calls[0][0];
-    expect(callArgs.input).toBe(customText);
-  });
-
-  test("preserves error details in result", async () => {
-    const errorMessage = "Specific API Error";
-    mockModerations.create = mock(() => {
-      throw new Error(errorMessage);
-    });
-
-    const result = await checkModeration(mockOpenAiClient, "test");
-
-    expect((result.error as Error).message).toBe(errorMessage);
-  });
-
-  test("handles undefined OpenAI result fields", async () => {
-    mockModerations.create = mock(async () => ({
-      results: [
-        {
-          flagged: undefined,
-          categories: undefined,
-        },
-      ],
-    }));
-
-    const result = await checkModeration(mockOpenAiClient, "test");
-
-    expect(result.flagged).toBe(false);
-    expect(result.categories).toBeNull();
-  });
-
-  test("correctly identifies moderation source as openai", async () => {
-    mockModerations.create = mock(async () => ({
-      results: [
-        {
-          flagged: false,
-          categories: {},
-        },
-      ],
-    }));
-
-    const result = await checkModeration(mockOpenAiClient, "clean content");
-
-    expect(result.source).toBe("openai");
-    expect(result.source).not.toBe("profanity");
-    expect(result.source).not.toBeNull();
-  });
-});

package/src/utils/format-amount.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { formatAmount, formatSignedAmount } from "./format-amount";
-
-describe("formatAmount", () => {
-  test("formats absolute number with currency symbol", () => {
-    const expected = new Intl.NumberFormat(undefined, {
-      maximumFractionDigits: 0,
-    }).format(1234);
-
-    expect(formatAmount(-1234)).toBe(`৳${expected}`);
-  });
-});
-
-describe("formatSignedAmount", () => {
-  test("uses minus sign for debit", () => {
-    const expected = new Intl.NumberFormat(undefined, {
-      maximumFractionDigits: 0,
-    }).format(2000);
-
-    expect(formatSignedAmount(2000, "debit")).toBe(`- ৳${expected}`);
-  });
-
-  test("uses plus sign for credit and absolute value", () => {
-    const expected = new Intl.NumberFormat(undefined, {
-      maximumFractionDigits: 0,
-    }).format(2000);
-
-    expect(formatSignedAmount(-2000, "credit")).toBe(`+ ৳${expected}`);
-  });
-});

package/src/utils/format-count.test.ts

@@ -1,56 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { formatCount } from "./format-count";
-
-describe("formatCount", () => {
-  test("formats zero and small numbers without suffix", () => {
-    expect(formatCount(0)).toBe("0");
-    expect(formatCount(7)).toBe("7");
-    expect(formatCount(999)).toBe("999");
-  });
-
-  test("handles negative numbers", () => {
-    expect(formatCount(-1000)).toBe("-1k");
-    expect(formatCount(-1500)).toBe("-1.5k");
-    expect(formatCount(-1_000_000)).toBe("-1M");
-  });
-
-  test("formats thousands with k suffix", () => {
-    expect(formatCount(1000)).toBe("1k");
-    expect(formatCount(10_000)).toBe("10k");
-    expect(formatCount(100_000)).toBe("100k");
-  });
-
-  test("shows decimal for non-round thousands", () => {
-    expect(formatCount(1500)).toBe("1.5k");
-    expect(formatCount(10_500)).toBe("10.5k");
-    expect(formatCount(15_500)).toBe("15.5k");
-  });
-
-  test("formats millions with M suffix", () => {
-    expect(formatCount(1_000_000)).toBe("1M");
-    expect(formatCount(10_000_000)).toBe("10M");
-    expect(formatCount(100_000_000)).toBe("100M");
-  });
-
-  test("shows decimal for non-round millions", () => {
-    expect(formatCount(1_500_000)).toBe("1.5M");
-    expect(formatCount(10_500_000)).toBe("10.5M");
-  });
-
-  test("formats billions with B suffix", () => {
-    expect(formatCount(1_000_000_000)).toBe("1B");
-    expect(formatCount(10_000_000_000)).toBe("10B");
-    expect(formatCount(100_000_000_000)).toBe("100B");
-  });
-
-  test("shows decimal for non-round billions", () => {
-    expect(formatCount(1_500_000_000)).toBe("1.5B");
-    expect(formatCount(2_100_000_000)).toBe("2.1B");
-  });
-
-  test("uses whole numbers for large round values", () => {
-    expect(formatCount(1000)).toBe("1k");
-    expect(formatCount(1_000_000)).toBe("1M");
-    expect(formatCount(1_000_000_000)).toBe("1B");
-  });
-});

package/src/utils/format-date.test.ts

@@ -1,19 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { formatDate } from "./format-date";
-
-describe("formatDate", () => {
-  test("returns dash for invalid date", () => {
-    expect(formatDate("not-a-date")).toBe("-");
-  });
-
-  test("formats a valid date", () => {
-    const input = "2026-02-13T00:00:00.000Z";
-    const expected = new Date(input).toLocaleDateString(undefined, {
-      month: "short",
-      day: "numeric",
-      year: "numeric",
-    });
-
-    expect(formatDate(input)).toBe(expected);
-  });
-});

package/src/utils/format-number.test.ts

@@ -1,29 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { formatNumber } from "./format-number";
-
-function digitsFromFormatted(formatted: string) {
-  const digits = formatted.replace(/\D/g, "");
-  return Number(digits);
-}
-
-describe("formatNumber", () => {
-  test("formats positive numbers and rounds correctly", () => {
-    expect(digitsFromFormatted(formatNumber(1234.56))).toBe(1235);
-  });
-
-  test("formats negative numbers using absolute value", () => {
-    expect(digitsFromFormatted(formatNumber(-9876.5))).toBe(9877);
-  });
-
-  test("formats zero", () => {
-    expect(digitsFromFormatted(formatNumber(0))).toBe(0);
-  });
-
-  test("rounds small fractional numbers to 0", () => {
-    expect(digitsFromFormatted(formatNumber(-0.4))).toBe(0);
-  });
-
-  test("formats large numbers", () => {
-    expect(digitsFromFormatted(formatNumber(1_000_000))).toBe(1_000_000);
-  });
-});

package/src/utils/format-plain-text.test.ts

@@ -1,36 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { formatMetadataKey, formatToPlainText } from "./format-plain-text";
-
-describe("formatToPlainText", () => {
-  test("returns empty string for null and undefined", () => {
-    expect(formatToPlainText(null)).toBe("");
-    expect(formatToPlainText(undefined)).toBe("");
-  });
-
-  test("formats booleans to Yes/No by default", () => {
-    expect(formatToPlainText(true)).toBe("Yes");
-    expect(formatToPlainText(false)).toBe("No");
-  });
-
-  test("can keep raw boolean text", () => {
-    expect(formatToPlainText(true, { formatBooleans: false })).toBe("true");
-  });
-
-  test("truncates long strings with ellipsis", () => {
-    expect(formatToPlainText("abcdef", { maxStringLength: 5 })).toBe("ab...");
-  });
-
-  test("stringifies objects and arrays", () => {
-    expect(formatToPlainText({ a: 1 })).toBe(JSON.stringify({ a: 1 }, null, 2));
-    expect(formatToPlainText(["x", "y"])).toBe(
-      JSON.stringify(["x", "y"], null, 2)
-    );
-  });
-});
-
-describe("formatMetadataKey", () => {
-  test("formats camelCase and snake_case keys", () => {
-    expect(formatMetadataKey("supporterName")).toBe("Supporter Name");
-    expect(formatMetadataKey("is_monthly")).toBe("Is monthly");
-  });
-});

package/src/utils/get-newsletter-post-link.test.ts

@@ -1,27 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { getNewsletterPostLink } from "./get-newsletter-post-link";
-
-describe("getNewsletterPostLink", () => {
-  test("builds relative path without baseUrl", () => {
-    const result = getNewsletterPostLink("johndoe", "my-post");
-    expect(result).toBe("/@johndoe/posts/my-post");
-  });
-
-  test("builds absolute URL with baseUrl", () => {
-    const result = getNewsletterPostLink(
-      "johndoe",
-      "my-post",
-      "https://hobenaki.coffee"
-    );
-    expect(result).toBe("https://hobenaki.coffee/@johndoe/posts/my-post");
-  });
-
-  test("handles different usernames and slugs", () => {
-    expect(getNewsletterPostLink("alice", "welcome-newsletter")).toBe(
-      "/@alice/posts/welcome-newsletter"
-    );
-    expect(getNewsletterPostLink("bob", "updates-2024")).toBe(
-      "/@bob/posts/updates-2024"
-    );
-  });
-});

package/src/utils/get-product-link.test.ts

@@ -1,34 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { getProductLink } from "./get-product-link";
-
-describe("getProductLink", () => {
-  test("builds product link with default baseUrl", () => {
-    const result = getProductLink("johndoe", "my-product");
-    expect(result).toBe(
-      "https://hobenakicoffee.com/@johndoe/shop/products/my-product"
-    );
-  });
-
-  test("builds product link with custom baseUrl", () => {
-    const result = getProductLink(
-      "johndoe",
-      "my-product",
-      "https://custom.com"
-    );
-    expect(result).toBe("https://custom.com/@johndoe/shop/products/my-product");
-  });
-
-  test("sanitizes username with whitespace", () => {
-    const result = getProductLink(" john doe ", "my-product");
-    expect(result).toBe(
-      "https://hobenakicoffee.com/@johndoe/shop/products/my-product"
-    );
-  });
-
-  test("does not encode slug - passes through as-is", () => {
-    const result = getProductLink("johndoe", "my product 123");
-    expect(result).toBe(
-      "https://hobenakicoffee.com/@johndoe/shop/products/my-product-123"
-    );
-  });
-});

package/src/utils/get-social-handle.test.ts

@@ -1,32 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { getSocialUrl } from "./get-social-handle";
-import { getUserPageLink } from "./get-user-page-link";
-
-describe("getSocialUrl", () => {
-  test("returns our platform URL when username is provided", () => {
-    expect(getSocialUrl("alice", "x", "ignored")).toBe(
-      getUserPageLink("alice")
-    );
-  });
-
-  test("returns # when required fields are missing", () => {
-    expect(getSocialUrl(undefined, "x", "")).toBe("#");
-    expect(getSocialUrl(undefined, null, "name")).toBe("#");
-  });
-
-  test("builds social URL with sanitized handle", () => {
-    expect(getSocialUrl(undefined, "instagram", " @john doe ")).toBe(
-      "https://instagram.com/johndoe"
-    );
-  });
-
-  test("uses platform-specific format for youtube", () => {
-    expect(getSocialUrl(undefined, "youtube", "Jane")).toBe(
-      "https://youtube.com/@Jane"
-    );
-  });
-
-  test("returns # for unsupported platform", () => {
-    expect(getSocialUrl(undefined, "myspace" as any, "Jane")).toBe("#");
-  });
-});

package/src/utils/get-social-link.test.ts

@@ -1,63 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { SupporterPlatforms } from "../constants";
-import { getSocialLink } from "./get-social-link";
-
-describe("getSocialLink", () => {
-  test("returns null when username or platform is missing", () => {
-    expect(getSocialLink(undefined, SupporterPlatforms.FACEBOOK)).toBeNull();
-    expect(getSocialLink("alice", undefined)).toBeNull();
-    expect(getSocialLink()).toBeNull();
-  });
-
-  test("returns correct Facebook URL", () => {
-    expect(getSocialLink("alice", SupporterPlatforms.FACEBOOK)).toBe(
-      "https://facebook.com/alice"
-    );
-  });
-
-  test("returns correct Instagram URL with spaces", () => {
-    expect(getSocialLink(" john doe ", SupporterPlatforms.INSTAGRAM)).toBe(
-      "https://instagram.com/johndoe"
-    );
-  });
-
-  test("returns correct TikTok URL", () => {
-    expect(getSocialLink("user123", SupporterPlatforms.TIKTOK)).toBe(
-      "https://tiktok.com/@user123"
-    );
-  });
-
-  test("returns correct YouTube URL", () => {
-    expect(getSocialLink("Jane", SupporterPlatforms.YOUTUBE)).toBe(
-      "https://youtube.com/Jane"
-    );
-  });
-
-  test("returns correct X (Twitter) URL", () => {
-    expect(getSocialLink("bob", SupporterPlatforms.X)).toBe(
-      "https://x.com/bob"
-    );
-  });
-
-  test("returns correct LinkedIn URL", () => {
-    expect(getSocialLink("johnsmith", SupporterPlatforms.LINKEDIN)).toBe(
-      "https://linkedin.com/in/johnsmith"
-    );
-  });
-
-  test("returns correct GitHub URL", () => {
-    expect(getSocialLink("octocat", SupporterPlatforms.GITHUB)).toBe(
-      "https://github.com/octocat"
-    );
-  });
-
-  test("returns null for unsupported platform", () => {
-    expect(getSocialLink("alice", "MYSPACE" as any)).toBeNull();
-  });
-
-  test("sanitizes username with special characters", () => {
-    expect(getSocialLink("user name!@#", SupporterPlatforms.FACEBOOK)).toBe(
-      "https://facebook.com/username!%40%23"
-    );
-  });
-});

package/src/utils/get-user-name-initials.test.ts

@@ -1,34 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { getInitials } from "./get-user-name-initials";
-
-describe("getInitials", () => {
-  test("returns initials for a full name", () => {
-    expect(getInitials("John Doe")).toBe("JD");
-    expect(getInitials("Jane Ann Smith")).toBe("JS");
-    expect(getInitials("Alice Bob Carol")).toBe("AC");
-  });
-
-  test("returns single initial for single name", () => {
-    expect(getInitials("John")).toBe("J");
-    expect(getInitials("A")).toBe("A");
-  });
-
-  test("handles extra spaces", () => {
-    expect(getInitials("  John   Doe  ")).toBe("JD");
-    expect(getInitials("   Alice   ")).toBe("A");
-    expect(getInitials("   Alice   Bob   Carol   ")).toBe("AC");
-  });
-
-  test("returns ? for empty or undefined", () => {
-    expect(getInitials("")).toBe("?");
-    expect(getInitials("   ")).toBe("?");
-    expect(getInitials(undefined)).toBe("?");
-    expect(getInitials(null)).toBe("?");
-  });
-
-  test("handles non-ASCII and special characters", () => {
-    expect(getInitials("Élodie Durand")).toBe("ÉD");
-    expect(getInitials("李 小龙")).toBe("李小");
-    expect(getInitials("O’Connor")).toBe("O");
-  });
-});