@hobenakicoffee/libraries 0.0.7 → 0.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hobenakicoffee/libraries",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "type": "module",
   "types": "src/index.ts",
   "exports": {

package/src/constants/common.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, test } from "bun:test";
+import { Visibility } from "./common";
+import type { Visibility as VisibilityType } from "./common";
+
+describe("Visibility", () => {
+  test("should contain all expected keys", () => {
+    const expectedKeys = ["PUBLIC", "PRIVATE"];
+    expect(Object.keys(Visibility)).toEqual(expectedKeys);
+  });
+
+  test("should have correct values for each visibility", () => {
+    expect(Visibility.PUBLIC).toBe("public");
+    expect(Visibility.PRIVATE).toBe("private");
+  });
+
+  test("should be usable as Visibility type", () => {
+    const pub: VisibilityType = "public";
+    const priv: VisibilityType = "private";
+    expect(pub).toBe("public");
+    expect(priv).toBe("private");
+  });
+
+  test("should have 2 visibilities", () => {
+    expect(Object.keys(Visibility).length).toBe(2);
+  });
+
+  test("all values should be lowercase strings", () => {
+    Object.values(Visibility).forEach((v) => {
+      expect(v).toBe(v.toLowerCase() as VisibilityType);
+      expect(typeof v).toBe("string");
+    });
+  });
+});

package/src/constants/common.ts

@@ -0,0 +1,6 @@
+export const Visibility = {
+  PUBLIC: "public",
+  PRIVATE: "private",
+} as const;
+
+export type Visibility = (typeof Visibility)[keyof typeof Visibility];

package/src/constants/index.ts

@@ -1,80 +1,5 @@
-export const productInfo = {
-  name: "হবে নাকি Coffee?",
-  domain: "https://www.hobenakicoffee.com",
-  twitterHandle: "@hobenakicoffee",
-  title: "চিন্তা ছাড়া আয়, শুরু করো তাই — হবে নাকি Coffee, ঝামেলা সব ছাই!",
-  description:
-    "‘হবে নাকি Coffee?’ দিয়ে যে কেউ ঝামেলা ছাড়াই নিজের অনলাইন ব্যবসা বা আয় শুরু করতে পারে। লিগ্যাল, কোম্পানি ফরমেশন বা কাগজপত্র নিয়ে ভাবতে হবে না—সবকিছু আমরা দেখি। শুধু একটি লিংক শেয়ার করুন, আর যে কেউ Coffee/Tip দিয়ে আপনাকে সাপোর্ট করতে পারবে। চাইলে এক্সক্লুসিভ কনটেন্ট, ডিজিটাল পণ্য বা মার্চ, গিফট, পার্সোনাল শাউটআউট কিংবা সার্ভিসও অফার করা যায়। কনটেন্ট ক্রিয়েটর, ফ্রিল্যান্সার, ছোট ব্যবসা, কমিউনিটি বা ইভেন্ট অর্গানাইজার, চ্যারিটি উদ্যোগ বা ব্যক্তিগত লক্ষ্য—সবার জন্যই HobeNakiCoffee হলো অনলাইনে আয় ও সাপোর্ট নেওয়ার সহজ, ঝামেলামুক্ত প্ল্যাটফর্ম।",
-  keywords:
-    "হবে নাকি Coffee, buy me a coffee, tip jar, support link, support me, donate, online income bangla, extra income, monetization, payment link, audience support, exclusive content, digital product, merch, shoutout, fundraising, charity, small business support, freelancer support, Bangladesh",
-};
-
-export const companyInfo = {
-  name: "Shamscorner LLC",
-  contactEmail: "mail@shamscorner.com",
-  contactPhone: "+1(817) 973-7285",
-  contactLocation: "7320, 1021 E Lincolnway, Cheyenne, WY, Laramie, US, 82001",
-  contactWhatsapp: "https://wa.me/13072212615",
-  contactX: "https://www.x.com/shamscorner_llc",
-  contactFacebook: "https://www.facebook.com/shamscorner.llc",
-  contactYoutube: "https://www.youtube.com/@shamscorner",
-  contactLinkedin: "https://www.linkedin.com/company/shamscorner",
-  domain: "https://www.shamscorner.com",
-  postalAddress: {
-    streetAddress: "1021 E Lincolnway Suite 7320",
-    addressLocality: "Cheyenne",
-    addressRegion: "WY",
-    postalCode: "82001",
-    addressCountry: "US",
-  },
-};
-
-export const PaymentTypes = {
-  SUBSCRIPTION: "subscription",
-  ONE_TIME: "one-time",
-} as const;
-
-export type PaymentType = (typeof PaymentTypes)[keyof typeof PaymentTypes];
-
-export const SupporterPlatforms = {
-  FACEBOOK: "facebook",
-  X: "x",
-  INSTAGRAM: "instagram",
-  YOUTUBE: "youtube",
-  GITHUB: "github",
-  LINKEDIN: "linkedin",
-  TWITCH: "twitch",
-  TIKTOK: "tiktok",
-  THREADS: "threads",
-  WHATSAPP: "whatsapp",
-  TELEGRAM: "telegram",
-  DISCORD: "discord",
-  REDDIT: "reddit",
-  PINTEREST: "pinterest",
-  MEDIUM: "medium",
-  DEVTO: "devto",
-  BEHANCE: "behance",
-  DRIBBBLE: "dribbble",
-} as const;
-
-export type SupporterPlatform =
-  (typeof SupporterPlatforms)[keyof typeof SupporterPlatforms];
-
-export const PaymentStatuses = {
-  PENDING: "pending",
-  COMPLETED: "completed",
-  FAILED: "failed",
-  CANCELLED: "cancelled",
-  REFUNDED: "refunded",
-  REVIEWING: "reviewing",
-} as const;
-
-export type PaymentStatus =
-  (typeof PaymentStatuses)[keyof typeof PaymentStatuses];
-
-export const ServiceTypes = {
-  GIFT: "gift",
-  EXCLUSIVE_CONTENT: "exclusive_content",
-} as const;
-
-export type ServiceType = (typeof ServiceTypes)[keyof typeof ServiceTypes];
+export * from "./common";
+export * from "./legal";
+export * from "./payment";
+export * from "./platforms";
+export * from "./services";

package/src/constants/legal.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, test } from "bun:test";
+import { productInfo, companyInfo } from "./legal";
+
+describe("productInfo", () => {
+  test("should have all required fields", () => {
+    expect(productInfo).toHaveProperty("name");
+    expect(productInfo).toHaveProperty("domain");
+    expect(productInfo).toHaveProperty("twitterHandle");
+    expect(productInfo).toHaveProperty("title");
+    expect(productInfo).toHaveProperty("description");
+    expect(productInfo).toHaveProperty("keywords");
+  });
+
+  test("should have correct types for fields", () => {
+    expect(typeof productInfo.name).toBe("string");
+    expect(typeof productInfo.domain).toBe("string");
+    expect(typeof productInfo.twitterHandle).toBe("string");
+    expect(typeof productInfo.title).toBe("string");
+    expect(typeof productInfo.description).toBe("string");
+    expect(typeof productInfo.keywords).toBe("string");
+  });
+});
+
+describe("companyInfo", () => {
+  test("should have all required fields", () => {
+    expect(companyInfo).toHaveProperty("name");
+    expect(companyInfo).toHaveProperty("contactEmail");
+    expect(companyInfo).toHaveProperty("contactPhone");
+    expect(companyInfo).toHaveProperty("contactLocation");
+    expect(companyInfo).toHaveProperty("contactWhatsapp");
+    expect(companyInfo).toHaveProperty("contactX");
+    expect(companyInfo).toHaveProperty("contactFacebook");
+    expect(companyInfo).toHaveProperty("contactYoutube");
+    expect(companyInfo).toHaveProperty("contactLinkedin");
+    expect(companyInfo).toHaveProperty("domain");
+    expect(companyInfo).toHaveProperty("postalAddress");
+  });
+
+  test("should have correct types for fields", () => {
+    expect(typeof companyInfo.name).toBe("string");
+    expect(typeof companyInfo.contactEmail).toBe("string");
+    expect(typeof companyInfo.contactPhone).toBe("string");
+    expect(typeof companyInfo.contactLocation).toBe("string");
+    expect(typeof companyInfo.contactWhatsapp).toBe("string");
+    expect(typeof companyInfo.contactX).toBe("string");
+    expect(typeof companyInfo.contactFacebook).toBe("string");
+    expect(typeof companyInfo.contactYoutube).toBe("string");
+    expect(typeof companyInfo.contactLinkedin).toBe("string");
+    expect(typeof companyInfo.domain).toBe("string");
+    expect(typeof companyInfo.postalAddress).toBe("object");
+  });
+
+  test("postalAddress should have all required fields", () => {
+    const address = companyInfo.postalAddress;
+    expect(address).toHaveProperty("streetAddress");
+    expect(address).toHaveProperty("addressLocality");
+    expect(address).toHaveProperty("addressRegion");
+    expect(address).toHaveProperty("postalCode");
+    expect(address).toHaveProperty("addressCountry");
+  });
+});

package/src/constants/legal.ts

@@ -0,0 +1,30 @@
+export const productInfo = {
+  name: "হবে নাকি Coffee?",
+  domain: "https://www.hobenakicoffee.com",
+  twitterHandle: "@hobenakicoffee",
+  title: "চিন্তা ছাড়া আয়, শুরু করো তাই — হবে নাকি Coffee, ঝামেলা সব ছাই!",
+  description:
+    "‘হবে নাকি Coffee?’ দিয়ে যে কেউ ঝামেলা ছাড়াই নিজের অনলাইন ব্যবসা বা আয় শুরু করতে পারে। লিগ্যাল, কোম্পানি ফরমেশন বা কাগজপত্র নিয়ে ভাবতে হবে না—সবকিছু আমরা দেখি। শুধু একটি লিংক শেয়ার করুন, আর যে কেউ Coffee/Tip দিয়ে আপনাকে সাপোর্ট করতে পারবে। চাইলে এক্সক্লুসিভ কনটেন্ট, ডিজিটাল পণ্য বা মার্চ, গিফট, পার্সোনাল শাউটআউট কিংবা সার্ভিসও অফার করা যায়। কনটেন্ট ক্রিয়েটর, ফ্রিল্যান্সার, ছোট ব্যবসা, কমিউনিটি বা ইভেন্ট অর্গানাইজার, চ্যারিটি উদ্যোগ বা ব্যক্তিগত লক্ষ্য—সবার জন্যই HobeNakiCoffee হলো অনলাইনে আয় ও সাপোর্ট নেওয়ার সহজ, ঝামেলামুক্ত প্ল্যাটফর্ম।",
+  keywords:
+    "হবে নাকি Coffee, buy me a coffee, tip jar, support link, support me, donate, online income bangla, extra income, monetization, payment link, audience support, exclusive content, digital product, merch, shoutout, fundraising, charity, small business support, freelancer support, Bangladesh",
+};
+
+export const companyInfo = {
+  name: "Shamscorner LLC",
+  contactEmail: "mail@shamscorner.com",
+  contactPhone: "+1(817) 973-7285",
+  contactLocation: "7320, 1021 E Lincolnway, Cheyenne, WY, Laramie, US, 82001",
+  contactWhatsapp: "https://wa.me/13072212615",
+  contactX: "https://www.x.com/shamscorner_llc",
+  contactFacebook: "https://www.facebook.com/shamscorner.llc",
+  contactYoutube: "https://www.youtube.com/@shamscorner",
+  contactLinkedin: "https://www.linkedin.com/company/shamscorner",
+  domain: "https://www.shamscorner.com",
+  postalAddress: {
+    streetAddress: "1021 E Lincolnway Suite 7320",
+    addressLocality: "Cheyenne",
+    addressRegion: "WY",
+    postalCode: "82001",
+    addressCountry: "US",
+  },
+};

package/src/constants/payment.test.ts

@@ -0,0 +1,188 @@
+import { describe, expect, test } from "bun:test";
+import {
+  PaymentProviders,
+  PaymentStatuses,
+  PaymentTypes,
+  PaymentDirections,
+} from "./payment";
+import type {
+  PaymentProvider,
+  PaymentStatus,
+  PaymentType,
+  PaymentDirection,
+} from "./payment";
+
+describe("PaymentStatuses", () => {
+  test("should contain all expected status keys", () => {
+    const expectedKeys = [
+      "PENDING",
+      "PROCESSING",
+      "COMPLETED",
+      "FAILED",
+      "REVERSED",
+      "CANCELLED",
+      "REFUNDED",
+      "REVIEWING",
+    ];
+    expect(Object.keys(PaymentStatuses)).toEqual(expectedKeys);
+  });
+
+  test("should have correct values for each status", () => {
+    expect(PaymentStatuses.PENDING).toBe("pending");
+    expect(PaymentStatuses.PROCESSING).toBe("processing");
+    expect(PaymentStatuses.COMPLETED).toBe("completed");
+    expect(PaymentStatuses.FAILED).toBe("failed");
+    expect(PaymentStatuses.REVERSED).toBe("reversed");
+    expect(PaymentStatuses.CANCELLED).toBe("cancelled");
+    expect(PaymentStatuses.REFUNDED).toBe("refunded");
+    expect(PaymentStatuses.REVIEWING).toBe("reviewing");
+  });
+
+  test("should be read-only at compile time", () => {
+    // TypeScript prevents modification at compile time with 'as const'
+    // This test verifies the structure is correct
+    expect(Object.isFrozen(PaymentStatuses)).toBe(false);
+    expect(typeof PaymentStatuses).toBe("object");
+  });
+
+  test("PaymentStatus type should accept valid status values", () => {
+    const validStatus: PaymentStatus = "completed";
+    expect(validStatus).toBe("completed");
+  });
+
+  test("should have 8 payment statuses", () => {
+    expect(Object.keys(PaymentStatuses).length).toBe(8);
+  });
+
+  test("all values should be lowercase strings", () => {
+    Object.values(PaymentStatuses).forEach((status) => {
+      expect(status).toBe(status.toLowerCase() as PaymentStatus);
+      expect(typeof status).toBe("string");
+    });
+  });
+});
+
+describe("PaymentTypes", () => {
+  test("should contain all expected keys", () => {
+    const expectedKeys = ["SUBSCRIPTION", "ONE_TIME", "PAYOUT"];
+    expect(Object.keys(PaymentTypes)).toEqual(expectedKeys);
+  });
+
+  test("should have correct values for each type", () => {
+    expect(PaymentTypes.SUBSCRIPTION).toBe("subscription");
+    expect(PaymentTypes.ONE_TIME).toBe("one-time");
+    expect(PaymentTypes.PAYOUT).toBe("payout");
+  });
+
+  test("should be read-only at compile time", () => {
+    // TypeScript prevents modification at compile time with 'as const'
+    // This test verifies the structure is correct
+    expect(Object.isFrozen(PaymentTypes)).toBe(false);
+    expect(typeof PaymentTypes).toBe("object");
+  });
+
+  test("PaymentType type should accept valid type values", () => {
+    const validType: PaymentType = "subscription";
+    expect(validType).toBe("subscription");
+  });
+
+  test("should have 3 payment types", () => {
+    expect(Object.keys(PaymentTypes).length).toBe(3);
+  });
+
+  test("all values should be lowercase or kebab-case strings", () => {
+    Object.values(PaymentTypes).forEach((type) => {
+      expect(typeof type).toBe("string");
+      // Check that it contains lowercase letters, hyphens, or underscores
+      expect(type).toMatch(/^[a-z_-]+$/);
+    });
+  });
+});
+
+describe("PaymentProviders", () => {
+  test("should contain all expected provider keys", () => {
+    const expectedKeys = [
+      "HOBENAKICOFFEE",
+      "BKASH",
+      "NAGAD",
+      "ROCKET",
+      "UPAY",
+      "SSLCOMMERZ",
+      "AAMARPAY",
+      "PORTWALLET",
+      "TAP",
+      "OTHER",
+    ];
+    expect(Object.keys(PaymentProviders)).toEqual(expectedKeys);
+  });
+
+  test("should have correct values for each provider", () => {
+    expect(PaymentProviders.HOBENAKICOFFEE).toBe("HobeNakiCoffee");
+    expect(PaymentProviders.BKASH).toBe("Bkash");
+    expect(PaymentProviders.NAGAD).toBe("Nagad");
+    expect(PaymentProviders.ROCKET).toBe("Rocket");
+    expect(PaymentProviders.UPAY).toBe("Upay");
+    expect(PaymentProviders.SSLCOMMERZ).toBe("SSLCommerz");
+    expect(PaymentProviders.AAMARPAY).toBe("Aamarpay");
+    expect(PaymentProviders.PORTWALLET).toBe("Portwallet");
+    expect(PaymentProviders.TAP).toBe("Tap");
+    expect(PaymentProviders.OTHER).toBe("Other");
+  });
+  test("should allow HOBENAKICOFFEE as PaymentProvider type", () => {
+    const provider: PaymentProvider = PaymentProviders.HOBENAKICOFFEE;
+    expect(provider).toBe("HobeNakiCoffee");
+  });
+
+  test("should be read-only at compile time", () => {
+    // TypeScript prevents modification at compile time with 'as const'
+    // This test verifies the structure is correct
+    expect(Object.isFrozen(PaymentProviders)).toBe(false);
+    expect(typeof PaymentProviders).toBe("object");
+  });
+
+  test("PaymentProvider type should accept valid provider values", () => {
+    const validProvider: PaymentProvider = "Bkash";
+    expect(validProvider).toBe("Bkash");
+  });
+
+  test("should have 10 payment providers", () => {
+    expect(Object.keys(PaymentProviders).length).toBe(10);
+  });
+
+  test("all values should be lowercase strings", () => {
+    Object.values(PaymentProviders).forEach((provider) => {
+      expect(provider).toBe(provider as PaymentProvider);
+      expect(typeof provider).toBe("string");
+    });
+  });
+});
+
+describe("PaymentDirections", () => {
+  test("should contain all expected direction keys", () => {
+    const expectedKeys = ["DEBIT", "CREDIT"];
+    expect(Object.keys(PaymentDirections)).toEqual(expectedKeys);
+  });
+
+  test("should have correct values for each direction", () => {
+    expect(PaymentDirections.DEBIT).toBe("debit");
+    expect(PaymentDirections.CREDIT).toBe("credit");
+  });
+
+  test("should be usable as PaymentDirection type", () => {
+    const debit: PaymentDirection = "debit";
+    const credit: PaymentDirection = "credit";
+    expect(debit).toBe("debit");
+    expect(credit).toBe("credit");
+  });
+
+  test("should have 2 payment directions", () => {
+    expect(Object.keys(PaymentDirections).length).toBe(2);
+  });
+
+  test("all values should be lowercase strings", () => {
+    Object.values(PaymentDirections).forEach((direction) => {
+      expect(direction).toBe(direction.toLowerCase() as PaymentDirection);
+      expect(typeof direction).toBe("string");
+    });
+  });
+});

package/src/constants/payment.ts

@@ -0,0 +1,45 @@
+export const PaymentTypes = {
+  SUBSCRIPTION: "subscription",
+  ONE_TIME: "one-time",
+  PAYOUT: "payout",
+} as const;
+
+export type PaymentType = (typeof PaymentTypes)[keyof typeof PaymentTypes];
+
+export const PaymentStatuses = {
+  PENDING: "pending",
+  PROCESSING: "processing",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  REVERSED: "reversed",
+  CANCELLED: "cancelled",
+  REFUNDED: "refunded",
+  REVIEWING: "reviewing",
+} as const;
+
+export type PaymentStatus =
+  (typeof PaymentStatuses)[keyof typeof PaymentStatuses];
+
+export const PaymentProviders = {
+  HOBENAKICOFFEE: "HobeNakiCoffee",
+  BKASH: "Bkash",
+  NAGAD: "Nagad",
+  ROCKET: "Rocket",
+  UPAY: "Upay",
+  SSLCOMMERZ: "SSLCommerz",
+  AAMARPAY: "Aamarpay",
+  PORTWALLET: "Portwallet",
+  TAP: "Tap",
+  OTHER: "Other",
+} as const;
+
+export type PaymentProvider =
+  (typeof PaymentProviders)[keyof typeof PaymentProviders];
+
+export const PaymentDirections = {
+  DEBIT: "debit",
+  CREDIT: "credit",
+} as const;
+
+export type PaymentDirection =
+  (typeof PaymentDirections)[keyof typeof PaymentDirections];

package/src/constants/platforms.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, test } from "bun:test";
+import { SupporterPlatforms } from "./platforms";
+import type { SupporterPlatform } from "./platforms";
+
+describe("SupporterPlatforms", () => {
+  test("should contain all expected platform keys", () => {
+    const expectedKeys = [
+      "FACEBOOK",
+      "X",
+      "INSTAGRAM",
+      "YOUTUBE",
+      "GITHUB",
+      "LINKEDIN",
+      "TWITCH",
+      "TIKTOK",
+      "THREADS",
+      "WHATSAPP",
+      "TELEGRAM",
+      "DISCORD",
+      "REDDIT",
+      "PINTEREST",
+      "MEDIUM",
+      "DEVTO",
+      "BEHANCE",
+      "DRIBBBLE",
+    ];
+    expect(Object.keys(SupporterPlatforms)).toEqual(expectedKeys);
+  });
+
+  test("should have correct values for each platform", () => {
+    expect(SupporterPlatforms.FACEBOOK).toBe("facebook");
+    expect(SupporterPlatforms.X).toBe("x");
+    expect(SupporterPlatforms.INSTAGRAM).toBe("instagram");
+    expect(SupporterPlatforms.YOUTUBE).toBe("youtube");
+    expect(SupporterPlatforms.GITHUB).toBe("github");
+    expect(SupporterPlatforms.LINKEDIN).toBe("linkedin");
+    expect(SupporterPlatforms.TWITCH).toBe("twitch");
+    expect(SupporterPlatforms.TIKTOK).toBe("tiktok");
+    expect(SupporterPlatforms.THREADS).toBe("threads");
+    expect(SupporterPlatforms.WHATSAPP).toBe("whatsapp");
+    expect(SupporterPlatforms.TELEGRAM).toBe("telegram");
+    expect(SupporterPlatforms.DISCORD).toBe("discord");
+    expect(SupporterPlatforms.REDDIT).toBe("reddit");
+    expect(SupporterPlatforms.PINTEREST).toBe("pinterest");
+    expect(SupporterPlatforms.MEDIUM).toBe("medium");
+    expect(SupporterPlatforms.DEVTO).toBe("devto");
+    expect(SupporterPlatforms.BEHANCE).toBe("behance");
+    expect(SupporterPlatforms.DRIBBBLE).toBe("dribbble");
+  });
+
+  test("should be read-only at compile time", () => {
+    // TypeScript prevents modification at compile time with 'as const'
+    // This test verifies the structure is correct
+    expect(Object.isFrozen(SupporterPlatforms)).toBe(false);
+    expect(typeof SupporterPlatforms).toBe("object");
+  });
+
+  test("SupporterPlatform type should accept valid platform values", () => {
+    const validPlatform: SupporterPlatform = "facebook";
+    expect(validPlatform).toBe("facebook");
+  });
+
+  test("should have 18 platforms", () => {
+    expect(Object.keys(SupporterPlatforms).length).toBe(18);
+  });
+});

package/src/constants/platforms.ts

@@ -0,0 +1,23 @@
+export const SupporterPlatforms = {
+  FACEBOOK: "facebook",
+  X: "x",
+  INSTAGRAM: "instagram",
+  YOUTUBE: "youtube",
+  GITHUB: "github",
+  LINKEDIN: "linkedin",
+  TWITCH: "twitch",
+  TIKTOK: "tiktok",
+  THREADS: "threads",
+  WHATSAPP: "whatsapp",
+  TELEGRAM: "telegram",
+  DISCORD: "discord",
+  REDDIT: "reddit",
+  PINTEREST: "pinterest",
+  MEDIUM: "medium",
+  DEVTO: "devto",
+  BEHANCE: "behance",
+  DRIBBBLE: "dribbble",
+} as const;
+
+export type SupporterPlatform =
+  (typeof SupporterPlatforms)[keyof typeof SupporterPlatforms];

package/src/constants/services.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, test } from "bun:test";
+import { ServiceTypes } from "./services";
+import type { ServiceType } from "./services";
+
+describe("ServiceTypes", () => {
+  test("should contain all expected service type keys", () => {
+    const expectedKeys = ["GIFT", "EXCLUSIVE_CONTENT"];
+    expect(Object.keys(ServiceTypes)).toEqual(expectedKeys);
+  });
+
+  test("should have correct values for each service type", () => {
+    expect(ServiceTypes.GIFT).toBe("gift");
+    expect(ServiceTypes.EXCLUSIVE_CONTENT).toBe("exclusive_content");
+  });
+
+  test("should be read-only at compile time", () => {
+    // TypeScript prevents modification at compile time with 'as const'
+    // This test verifies the structure is correct
+    expect(Object.isFrozen(ServiceTypes)).toBe(false);
+    expect(typeof ServiceTypes).toBe("object");
+  });
+
+  test("ServiceType type should accept valid service type values", () => {
+    const validType: ServiceType = "gift";
+    expect(validType).toBe("gift");
+  });
+
+  test("should have 2 service types", () => {
+    expect(Object.keys(ServiceTypes).length).toBe(2);
+  });
+
+  test("all values should be lowercase or snake_case strings", () => {
+    Object.values(ServiceTypes).forEach((type) => {
+      expect(typeof type).toBe("string");
+      // Check that it only contains lowercase letters and underscores
+      expect(type).toMatch(/^[a-z_]+$/);
+    });
+  });
+});

package/src/constants/services.ts

@@ -0,0 +1,6 @@
+export const ServiceTypes = {
+  GIFT: "gift",
+  EXCLUSIVE_CONTENT: "exclusive_content",
+} as const;
+
+export type ServiceType = (typeof ServiceTypes)[keyof typeof ServiceTypes];

package/src/constants/index.test.ts

@@ -1,198 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  SupporterPlatforms,
-  PaymentStatuses,
-  ServiceTypes,
-  PaymentTypes,
-} from "./index";
-import type {
-  SupporterPlatform,
-  PaymentStatus,
-  ServiceType,
-  PaymentType,
-} from "./index";
-
-describe("SupporterPlatforms", () => {
-  test("should contain all expected platform keys", () => {
-    const expectedKeys = [
-      "FACEBOOK",
-      "X",
-      "INSTAGRAM",
-      "YOUTUBE",
-      "GITHUB",
-      "LINKEDIN",
-      "TWITCH",
-      "TIKTOK",
-      "THREADS",
-      "WHATSAPP",
-      "TELEGRAM",
-      "DISCORD",
-      "REDDIT",
-      "PINTEREST",
-      "MEDIUM",
-      "DEVTO",
-      "BEHANCE",
-      "DRIBBBLE",
-    ];
-
-    expect(Object.keys(SupporterPlatforms)).toEqual(expectedKeys);
-  });
-
-  test("should have correct values for each platform", () => {
-    expect(SupporterPlatforms.FACEBOOK).toBe("facebook");
-    expect(SupporterPlatforms.X).toBe("x");
-    expect(SupporterPlatforms.INSTAGRAM).toBe("instagram");
-    expect(SupporterPlatforms.YOUTUBE).toBe("youtube");
-    expect(SupporterPlatforms.GITHUB).toBe("github");
-    expect(SupporterPlatforms.LINKEDIN).toBe("linkedin");
-    expect(SupporterPlatforms.TWITCH).toBe("twitch");
-    expect(SupporterPlatforms.TIKTOK).toBe("tiktok");
-    expect(SupporterPlatforms.THREADS).toBe("threads");
-    expect(SupporterPlatforms.WHATSAPP).toBe("whatsapp");
-    expect(SupporterPlatforms.TELEGRAM).toBe("telegram");
-    expect(SupporterPlatforms.DISCORD).toBe("discord");
-    expect(SupporterPlatforms.REDDIT).toBe("reddit");
-    expect(SupporterPlatforms.PINTEREST).toBe("pinterest");
-    expect(SupporterPlatforms.MEDIUM).toBe("medium");
-    expect(SupporterPlatforms.DEVTO).toBe("devto");
-    expect(SupporterPlatforms.BEHANCE).toBe("behance");
-    expect(SupporterPlatforms.DRIBBBLE).toBe("dribbble");
-  });
-
-  test("should be read-only at compile time", () => {
-    // TypeScript prevents modification at compile time with 'as const'
-    // This test verifies the structure is correct
-    expect(Object.isFrozen(SupporterPlatforms)).toBe(false);
-    expect(typeof SupporterPlatforms).toBe("object");
-  });
-
-  test("SupporterPlatform type should accept valid platform values", () => {
-    const validPlatform: SupporterPlatform = "facebook";
-    expect(validPlatform).toBe("facebook");
-  });
-
-  test("should have 18 platforms", () => {
-    expect(Object.keys(SupporterPlatforms).length).toBe(18);
-  });
-});
-
-describe("PaymentStatuses", () => {
-  test("should contain all expected status keys", () => {
-    const expectedKeys = [
-      "PENDING",
-      "COMPLETED",
-      "FAILED",
-      "CANCELLED",
-      "REFUNDED",
-      "REVIEWING",
-    ];
-
-    expect(Object.keys(PaymentStatuses)).toEqual(expectedKeys);
-  });
-
-  test("should have correct values for each status", () => {
-    expect(PaymentStatuses.PENDING).toBe("pending");
-    expect(PaymentStatuses.COMPLETED).toBe("completed");
-    expect(PaymentStatuses.FAILED).toBe("failed");
-    expect(PaymentStatuses.CANCELLED).toBe("cancelled");
-    expect(PaymentStatuses.REFUNDED).toBe("refunded");
-    expect(PaymentStatuses.REVIEWING).toBe("reviewing");
-  });
-
-  test("should be read-only at compile time", () => {
-    // TypeScript prevents modification at compile time with 'as const'
-    // This test verifies the structure is correct
-    expect(Object.isFrozen(PaymentStatuses)).toBe(false);
-    expect(typeof PaymentStatuses).toBe("object");
-  });
-
-  test("PaymentStatus type should accept valid status values", () => {
-    const validStatus: PaymentStatus = "completed";
-    expect(validStatus).toBe("completed");
-  });
-
-  test("should have 6 payment statuses", () => {
-    expect(Object.keys(PaymentStatuses).length).toBe(6);
-  });
-
-  test("all values should be lowercase strings", () => {
-    Object.values(PaymentStatuses).forEach((status) => {
-      expect(status).toBe(status.toLowerCase() as PaymentStatus);
-      expect(typeof status).toBe("string");
-    });
-  });
-});
-
-describe("ServiceTypes", () => {
-  test("should contain all expected service type keys", () => {
-    const expectedKeys = ["GIFT", "EXCLUSIVE_CONTENT"];
-
-    expect(Object.keys(ServiceTypes)).toEqual(expectedKeys);
-  });
-
-  test("should have correct values for each service type", () => {
-    expect(ServiceTypes.GIFT).toBe("gift");
-    expect(ServiceTypes.EXCLUSIVE_CONTENT).toBe("exclusive_content");
-  });
-
-  test("should be read-only at compile time", () => {
-    // TypeScript prevents modification at compile time with 'as const'
-    // This test verifies the structure is correct
-    expect(Object.isFrozen(ServiceTypes)).toBe(false);
-    expect(typeof ServiceTypes).toBe("object");
-  });
-
-  test("ServiceType type should accept valid service type values", () => {
-    const validType: ServiceType = "gift";
-    expect(validType).toBe("gift");
-  });
-
-  test("should have 2 service types", () => {
-    expect(Object.keys(ServiceTypes).length).toBe(2);
-  });
-
-  test("all values should be lowercase or snake_case strings", () => {
-    Object.values(ServiceTypes).forEach((type) => {
-      expect(typeof type).toBe("string");
-      // Check that it only contains lowercase letters and underscores
-      expect(type).toMatch(/^[a-z_]+$/);
-    });
-  });
-});
-
-describe("PaymentTypes", () => {
-  test("should contain all expected keys", () => {
-    const expectedKeys = ["SUBSCRIPTION", "ONE_TIME"];
-
-    expect(Object.keys(PaymentTypes)).toEqual(expectedKeys);
-  });
-
-  test("should have correct values for each type", () => {
-    expect(PaymentTypes.SUBSCRIPTION).toBe("subscription");
-    expect(PaymentTypes.ONE_TIME).toBe("one-time");
-  });
-
-  test("should be read-only at compile time", () => {
-    // TypeScript prevents modification at compile time with 'as const'
-    // This test verifies the structure is correct
-    expect(Object.isFrozen(PaymentTypes)).toBe(false);
-    expect(typeof PaymentTypes).toBe("object");
-  });
-
-  test("PaymentType type should accept valid type values", () => {
-    const validType: PaymentType = "subscription";
-    expect(validType).toBe("subscription");
-  });
-
-  test("should have 2 payment types", () => {
-    expect(Object.keys(PaymentTypes).length).toBe(2);
-  });
-
-  test("all values should be lowercase or kebab-case strings", () => {
-    Object.values(PaymentTypes).forEach((type) => {
-      expect(typeof type).toBe("string");
-      // Check that it contains lowercase letters, hyphens, or underscores
-      expect(type).toMatch(/^[a-z_-]+$/);
-    });
-  });
-});