@hobenakicoffee/libraries 3.4.2 → 4.0.0

package/src/constants/legal.test.ts

@@ -1,72 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { companyInfo, productInfo } 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 match exact values", () => {
-    expect(productInfo).toEqual({
-      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",
-      socials: {
-        facebook: "https://www.facebook.com/hobenakicoffee",
-        youtube: "https://www.youtube.com/@hobenakicoffee",
-        x: "https://x.com/hobenakicoffee",
-        instagram: "https://www.instagram.com/hobenakicoffee",
-        tiktok: "https://www.tiktok.com/@hobenakicoffee",
-      },
-    });
-  });
-});
-
-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 match exact values", () => {
-    expect(companyInfo).toEqual({
-      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

@@ -1,259 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type {
-  PaymentDirection,
-  PaymentProvider,
-  PaymentStatus,
-  PaymentType,
-  PayoutProvider,
-  WithdrawalStatus,
-} from "./payment";
-import {
-  PaymentDirections,
-  PaymentProviders,
-  PaymentStatuses,
-  PaymentTypes,
-  PayoutProviders,
-  WithdrawalStatuses,
-} 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",
-      "WITHDRAW_LOCK",
-      "WITHDRAW_RELEASE",
-      "WITHDRAW_COMPLETE",
-      "MANUAL_ADJUSTMENT",
-    ];
-    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");
-    expect(PaymentTypes.WITHDRAW_LOCK).toBe("withdraw_lock");
-    expect(PaymentTypes.WITHDRAW_RELEASE).toBe("withdraw_release");
-    expect(PaymentTypes.WITHDRAW_COMPLETE).toBe("withdraw_complete");
-    expect(PaymentTypes.MANUAL_ADJUSTMENT).toBe("manual_adjustment");
-  });
-
-  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 7 payment types", () => {
-    expect(Object.keys(PaymentTypes).length).toBe(7);
-  });
-
-  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("PayoutProviders", () => {
-  test("should contain all expected provider keys", () => {
-    const expectedKeys = ["BKASH", "NAGAD", "ROCKET", "BANK"];
-    expect(Object.keys(PayoutProviders)).toEqual(expectedKeys);
-  });
-
-  test("should have correct values for each provider", () => {
-    expect(PayoutProviders.BKASH).toBe("bkash");
-    expect(PayoutProviders.NAGAD).toBe("nagad");
-    expect(PayoutProviders.ROCKET).toBe("rocket");
-    expect(PayoutProviders.BANK).toBe("bank");
-  });
-
-  test("PayoutProvider type should accept valid provider values", () => {
-    const validProvider: PayoutProvider = "bkash";
-    expect(validProvider).toBe("bkash");
-  });
-
-  test("should have 4 payout providers", () => {
-    expect(Object.keys(PayoutProviders).length).toBe(4);
-  });
-});
-
-describe("WithdrawalStatuses", () => {
-  test("should contain all expected status keys", () => {
-    const expectedKeys = [
-      "REQUESTED",
-      "APPROVED",
-      "PROCESSING",
-      "PAID",
-      "REJECTED",
-      "FAILED",
-    ];
-    expect(Object.keys(WithdrawalStatuses)).toEqual(expectedKeys);
-  });
-
-  test("should have correct values for each status", () => {
-    expect(WithdrawalStatuses.REQUESTED).toBe("requested");
-    expect(WithdrawalStatuses.APPROVED).toBe("approved");
-    expect(WithdrawalStatuses.PROCESSING).toBe("processing");
-    expect(WithdrawalStatuses.PAID).toBe("paid");
-    expect(WithdrawalStatuses.REJECTED).toBe("rejected");
-    expect(WithdrawalStatuses.FAILED).toBe("failed");
-  });
-
-  test("WithdrawalStatus type should accept valid status values", () => {
-    const validStatus: WithdrawalStatus = "processing";
-    expect(validStatus).toBe("processing");
-  });
-
-  test("should have 6 withdrawal statuses", () => {
-    expect(Object.keys(WithdrawalStatuses).length).toBe(6);
-  });
-});
-
-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/platforms.test.ts

@@ -1,66 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { SupporterPlatform } from "./platforms";
-import { SupporterPlatforms } 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/services.test.ts

@@ -1,58 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { ServiceType } from "./services";
-import { ServiceTypes } from "./services";
-
-describe("ServiceTypes", () => {
-  test("should contain all expected service type keys", () => {
-    const expectedKeys = [
-      "GIFT",
-      "DIGITAL_CONTENT",
-      "MY_SHOP",
-      "CONSULTANCY_1ON1",
-      "HIRE_ME",
-      "COURSES",
-      "LIVE_STREAMS",
-      "NEWSLETTER",
-      "WITHDRAWAL",
-      "FOLLOW",
-    ];
-    expect(Object.keys(ServiceTypes)).toEqual(expectedKeys);
-  });
-
-  test("should have correct values for each service type", () => {
-    expect(ServiceTypes.GIFT).toBe("gift");
-    expect(ServiceTypes.DIGITAL_CONTENT).toBe("digital_content");
-    expect(ServiceTypes.MY_SHOP).toBe("my_shop");
-    expect(ServiceTypes.CONSULTANCY_1ON1).toBe("consultancy_1on1");
-    expect(ServiceTypes.HIRE_ME).toBe("hire_me");
-    expect(ServiceTypes.COURSES).toBe("courses");
-    expect(ServiceTypes.LIVE_STREAMS).toBe("live_streams");
-    expect(ServiceTypes.NEWSLETTER).toBe("newsletter");
-    expect(ServiceTypes.WITHDRAWAL).toBe("withdrawal");
-    expect(ServiceTypes.FOLLOW).toBe("follow");
-  });
-
-  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 10 service types", () => {
-    expect(Object.keys(ServiceTypes).length).toBe(10);
-  });
-
-  test("all values should be lowercase or snake_case strings", () => {
-    for (const type of Object.values(ServiceTypes)) {
-      expect(typeof type).toBe("string");
-      // Check that it only contains lowercase letters, numbers, and underscores
-      expect(type).toMatch(/^[a-z0-9_]+$/);
-    }
-  });
-});

package/src/lib/utils.ts

@@ -1,6 +0,0 @@
-import { type ClassValue, clsx } from "clsx";
-import { twMerge } from "tailwind-merge";
-
-export function cn(...inputs: ClassValue[]) {
-  return twMerge(clsx(inputs));
-}

package/src/moderation/profanity-service.test.ts

@@ -1,106 +0,0 @@
-import { describe, expect, mock, test } from "bun:test";
-import {
-  badwordsMatcher,
-  containsBanglaSwear,
-  containsProfanity,
-} from "./profanity-service";
-
-mock.module("obscenity", () => ({
-  englishDataset: { build: () => ({ patterns: [], masks: [] }) },
-  englishRecommendedTransformers: {},
-  RegExpMatcher: class {
-    hasMatch() {
-      return false;
-    }
-  },
-}));
-
-describe("containsBanglaSwear", () => {
-  test("returns false when no bad words found", () => {
-    const result = containsBanglaSwear("ভালো কথা");
-    expect(result).toBe(false);
-  });
-
-  test("returns true when Bangla bad word is found", () => {
-    const result = containsBanglaSwear("খানকির ছেলে");
-    expect(result).toBe(true);
-  });
-
-  test("matches bad words in mixed text", () => {
-    const result = containsBanglaSwear("এটি খানকির ছেলে একটি বাক্য");
-    expect(result).toBe(true);
-  });
-
-  test("handles normalized unicode", () => {
-    const result = containsBanglaSwear("খানকির ছেলে");
-    expect(result).toBe(true);
-  });
-
-  test("returns false for empty string", () => {
-    const result = containsBanglaSwear("");
-    expect(result).toBe(false);
-  });
-
-  test("handles multiple bad words", () => {
-    const result = containsBanglaSwear("খানকির ছেলে এবং চোদানীর পোলা");
-    expect(result).toBe(true);
-  });
-
-  test("handles leetspeak variations", () => {
-    const result = containsBanglaSwear("খানকির ছেলে");
-    expect(typeof result).toBe("boolean");
-  });
-});
-
-describe("containsProfanity", () => {
-  test("returns false for clean text", () => {
-    const result = containsProfanity("এটি একটি পরিষ্কার বাক্য");
-    expect(result).toBe(false);
-  });
-
-  test("throws error for undefined input", () => {
-    expect(() => containsProfanity(undefined as unknown as string)).toThrow();
-  });
-
-  test("returns false for empty string", () => {
-    const result = containsProfanity("");
-    expect(result).toBe(false);
-  });
-
-  test("returns proper boolean structure", () => {
-    const result = containsProfanity("clean text");
-    expect(typeof result).toBe("boolean");
-  });
-
-  test("handles mixed English and Bangla text", () => {
-    const result = containsProfanity("hello world খানকির ছেলে content");
-    expect(result).toBe(true);
-  });
-
-  test("handles whitespace and punctuation", () => {
-    const result = containsProfanity("clean text!!!");
-    expect(result).toBe(false);
-  });
-
-  test("handles very long text", () => {
-    const longText = `clean text ${"word ".repeat(1000)}`;
-    const result = containsProfanity(longText);
-    expect(typeof result).toBe("boolean");
-  });
-
-  test("throws error for null input", () => {
-    expect(() => containsProfanity(null as unknown as string)).toThrow();
-  });
-});
-
-describe("badwordsMatcher", () => {
-  test("is a RegExpMatcher instance", () => {
-    expect(badwordsMatcher).toBeDefined();
-    expect(typeof badwordsMatcher.hasMatch).toBe("function");
-  });
-
-  test("hasMatch returns boolean", () => {
-    const result = badwordsMatcher.hasMatch("clean text");
-    expect(typeof result).toBe("boolean");
-  });
-});

package/src/providers/theme-provider.tsx

@@ -1,73 +0,0 @@
-import { createContext, useContext, useEffect, useState } from "react";
-
-type Theme = "dark" | "light" | "system";
-
-type ThemeProviderProps = {
-  children: React.ReactNode;
-  defaultTheme?: Theme;
-  storageKey?: string;
-};
-
-type ThemeProviderState = {
-  theme: Theme;
-  setTheme: (theme: Theme) => void;
-};
-
-const initialState: ThemeProviderState = {
-  theme: "system",
-  setTheme: () => null,
-};
-
-const ThemeProviderContext = createContext<ThemeProviderState>(initialState);
-
-export function ThemeProvider({
-  children,
-  defaultTheme = "system",
-  storageKey = "hobenakicoffee-app-ui-themes",
-  ...props
-}: ThemeProviderProps) {
-  const [theme, setTheme] = useState<Theme>(
-    () => (localStorage.getItem(storageKey) as Theme) || defaultTheme
-  );
-
-  useEffect(() => {
-    const root = window.document.documentElement;
-
-    root.classList.remove("light", "dark");
-
-    if (theme === "system") {
-      const systemTheme = window.matchMedia("(prefers-color-scheme: dark)")
-        .matches
-        ? "dark"
-        : "light";
-
-      root.classList.add(systemTheme);
-      return;
-    }
-
-    root.classList.add(theme);
-  }, [theme]);
-
-  const value = {
-    theme,
-    setTheme: (theme: Theme) => {
-      localStorage.setItem(storageKey, theme);
-      setTheme(theme);
-    },
-  };
-
-  return (
-    <ThemeProviderContext.Provider {...props} value={value}>
-      {children}
-    </ThemeProviderContext.Provider>
-  );
-}
-
-export const useTheme = () => {
-  const context = useContext(ThemeProviderContext);
-
-  if (context === undefined)
-    throw new Error("useTheme must be used within a ThemeProvider");
-
-  return context;
-};