@moontra/moonui-pro 2.20.1 → 2.20.3

package/src/use-pro-access.ts

@@ -1,141 +0,0 @@
-// Pro Access Hook
-// Kullanıcının pro componentlere erişim durumunu kontrol eder
-
-import React from 'react'
-import { useSession } from 'next-auth/react'
-import { useQuery } from '@tanstack/react-query'
-import { getComponentAccess } from '@/lib/component-metadata'
-
-interface UserSubscription {
-  userId: string
-  plan: 'free' | 'pro_monthly' | 'pro_annual' | 'pro_lifetime'
-  status: 'active' | 'expired' | 'cancelled' | 'trial'
-  expiresAt: Date | null // lifetime için null
-  createdAt: Date
-  updatedAt: Date
-}
-
-interface ProAccessStatus {
-  hasProAccess: boolean
-  subscription: UserSubscription | null | undefined
-  isLoading: boolean
-  error: Error | null
-  daysUntilExpiry: number | null
-}
-
-// Subscription durumunu API'den çek
-async function fetchSubscriptionStatus(): Promise<UserSubscription | null> {
-  const response = await fetch('/api/user/subscription-status')
-  
-  if (!response.ok) {
-    throw new Error('Subscription status fetch failed')
-  }
-  
-  const data = await response.json()
-  return data.subscription
-}
-
-// Pro erişim durumunu hesapla
-function calculateProAccess(subscription: UserSubscription | null | undefined): {
-  hasProAccess: boolean
-  daysUntilExpiry: number | null
-} {
-  if (!subscription) {
-    return { hasProAccess: false, daysUntilExpiry: null }
-  }
-
-  // Lifetime üyelik
-  if (subscription.plan === 'pro_lifetime') {
-    return { hasProAccess: true, daysUntilExpiry: null }
-  }
-
-  // Aktif olmayan subscription
-  if (subscription.status !== 'active') {
-    return { hasProAccess: false, daysUntilExpiry: null }
-  }
-
-  // Süre kontrolü
-  if (subscription.expiresAt) {
-    const now = new Date()
-    const expiryDate = new Date(subscription.expiresAt)
-    const daysUntilExpiry = Math.ceil((expiryDate.getTime() - now.getTime()) / (1000 * 60 * 60 * 24))
-    
-    return {
-      hasProAccess: daysUntilExpiry > 0,
-      daysUntilExpiry: daysUntilExpiry > 0 ? daysUntilExpiry : 0
-    }
-  }
-
-  return { hasProAccess: false, daysUntilExpiry: null }
-}
-
-export function useProAccess(): ProAccessStatus {
-  const { data: session, status } = useSession()
-  
-  const {
-    data: subscription,
-    isLoading,
-    error
-  } = useQuery({
-    queryKey: ['subscription-status', session?.user?.id],
-    queryFn: fetchSubscriptionStatus,
-    enabled: !!session?.user?.id && status === 'authenticated',
-    staleTime: 5 * 60 * 1000, // 5 dakika cache
-    refetchInterval: 10 * 60 * 1000, // 10 dakikada bir otomatik refresh
-  })
-
-  const { hasProAccess, daysUntilExpiry } = calculateProAccess(subscription)
-
-  return {
-    hasProAccess,
-    subscription,
-    isLoading: status === 'loading' || isLoading,
-    error: error as Error | null,
-    daysUntilExpiry
-  }
-}
-
-// Component erişim kontrolü için helper hook
-export function useComponentAccess(componentId: string) {
-  const { hasProAccess, isLoading } = useProAccess()
-  
-  const access = React.useMemo(() => {
-    return getComponentAccess(componentId, hasProAccess ? 'pro' : 'free')
-  }, [componentId, hasProAccess])
-  
-  return {
-    ...access,
-    isLoading,
-    canUse: access.access === 'unlocked',
-    isLocked: access.access === 'locked'
-  }
-}
-
-// Subscription durumu için utility functions
-export function getSubscriptionDisplayName(plan: string): string {
-  switch (plan) {
-    case 'pro_monthly':
-      return 'Pro Monthly'
-    case 'pro_annual':
-      return 'Pro Annual'
-    case 'pro_lifetime':
-      return 'Pro Lifetime'
-    default:
-      return 'Free'
-  }
-}
-
-export function getSubscriptionColor(status: string): string {
-  switch (status) {
-    case 'active':
-      return 'green'
-    case 'trial':
-      return 'blue'
-    case 'expired':
-      return 'red'
-    case 'cancelled':
-      return 'gray'
-    default:
-      return 'gray'
-  }
-}

package/src/use-scroll-animation.ts

@@ -1,219 +0,0 @@
-'use client'
-
-import { useEffect, useRef, useState } from 'react'
-import { useInView, useScroll, useTransform } from 'framer-motion'
-
-interface UseScrollAnimationOptions {
-  threshold?: number
-  triggerOnce?: boolean
-  rootMargin?: string
-}
-
-export function useScrollAnimation(options: UseScrollAnimationOptions = {}) {
-  const ref = useRef<HTMLElement>(null)
-  const isInView = useInView(ref, {
-    amount: options.threshold || 0.1,
-    once: options.triggerOnce ?? true,
-  })
-
-  return { ref, isInView }
-}
-
-export function useScrollProgress() {
-  const { scrollYProgress } = useScroll()
-  return scrollYProgress
-}
-
-export function useScrollBasedAnimation() {
-  const { scrollY } = useScroll()
-  const y = useTransform(scrollY, [0, 300], [0, -50])
-  const opacity = useTransform(scrollY, [0, 300], [1, 0])
-  const scale = useTransform(scrollY, [0, 300], [1, 0.8])
-
-  return { y, opacity, scale, scrollY }
-}
-
-export function useParallaxScroll(speed: number = 0.5) {
-  const ref = useRef<HTMLElement>(null)
-  const { scrollYProgress } = useScroll({
-    target: ref,
-    offset: ['start end', 'end start']
-  })
-  
-  const y = useTransform(scrollYProgress, [0, 1], [`-${speed * 100}%`, `${speed * 100}%`])
-  
-  return { ref, y }
-}
-
-export function useScrollDirection() {
-  const [scrollDirection, setScrollDirection] = useState<'up' | 'down'>('down')
-  const [scrollY, setScrollY] = useState(0)
-
-  useEffect(() => {
-    let ticking = false
-
-    const updateScrollDirection = () => {
-      const newScrollY = window.scrollY
-
-      if (Math.abs(newScrollY - scrollY) < 5) {
-        ticking = false
-        return
-      }
-
-      setScrollDirection(newScrollY > scrollY ? 'down' : 'up')
-      setScrollY(newScrollY)
-      ticking = false
-    }
-
-    const handleScroll = () => {
-      if (!ticking) {
-        requestAnimationFrame(updateScrollDirection)
-        ticking = true
-      }
-    }
-
-    window.addEventListener('scroll', handleScroll)
-    return () => window.removeEventListener('scroll', handleScroll)
-  }, [scrollY])
-
-  return { scrollDirection, scrollY }
-}
-
-export function useScrollToElement() {
-  const scrollToElement = (elementId: string, offset: number = 0) => {
-    const element = document.getElementById(elementId)
-    if (element) {
-      const elementPosition = element.offsetTop - offset
-      window.scrollTo({
-        top: elementPosition,
-        behavior: 'smooth'
-      })
-    }
-  }
-
-  return { scrollToElement }
-}
-
-interface UseInfiniteScrollOptions {
-  threshold?: number
-  rootMargin?: string
-}
-
-export function useInfiniteScroll(
-  callback: () => void,
-  options: UseInfiniteScrollOptions = {}
-) {
-  const ref = useRef<HTMLElement>(null)
-  const isInView = useInView(ref, {
-    amount: options.threshold || 0.1,
-  })
-
-  useEffect(() => {
-    if (isInView) {
-      callback()
-    }
-  }, [isInView, callback])
-
-  return ref
-}
-
-export function useScrollBasedScale() {
-  const ref = useRef<HTMLElement>(null)
-  const { scrollYProgress } = useScroll({
-    target: ref,
-    offset: ['start end', 'end start']
-  })
-  
-  const scale = useTransform(scrollYProgress, [0, 0.5, 1], [0.8, 1, 0.8])
-  const opacity = useTransform(scrollYProgress, [0, 0.2, 0.8, 1], [0, 1, 1, 0])
-  
-  return { ref, scale, opacity }
-}
-
-export function useScrollBasedRotation() {
-  const ref = useRef<HTMLElement>(null)
-  const { scrollYProgress } = useScroll({
-    target: ref,
-    offset: ['start end', 'end start']
-  })
-  
-  const rotate = useTransform(scrollYProgress, [0, 1], [0, 360])
-  
-  return { ref, rotate }
-}
-
-export function useScrollTriggeredCounter(
-  endValue: number,
-  duration: number = 2000
-) {
-  const [count, setCount] = useState(0)
-  const [isVisible, setIsVisible] = useState(false)
-  const ref = useRef<HTMLElement>(null)
-  
-  const isInView = useInView(ref, {
-    amount: 0.5,
-    once: true
-  })
-
-  useEffect(() => {
-    if (isInView && !isVisible) {
-      setIsVisible(true)
-      let startTime: number
-      
-      const animate = (currentTime: number) => {
-        if (!startTime) startTime = currentTime
-        const elapsed = currentTime - startTime
-        const progress = Math.min(elapsed / duration, 1)
-        
-        // Easing function for smooth animation
-        const easeOutQuart = 1 - Math.pow(1 - progress, 4)
-        setCount(Math.floor(easeOutQuart * endValue))
-        
-        if (progress < 1) {
-          requestAnimationFrame(animate)
-        }
-      }
-      
-      requestAnimationFrame(animate)
-    }
-  }, [isInView, endValue, duration, isVisible])
-
-  return { ref, count }
-}
-
-export function useScrollBasedBlur() {
-  const { scrollY } = useScroll()
-  const blur = useTransform(scrollY, [0, 300], [0, 10])
-  
-  return blur
-}
-
-export function useScrollSnapPoints(snapPoints: number[]) {
-  const [currentSnap, setCurrentSnap] = useState(0)
-  
-  useEffect(() => {
-    const handleScroll = () => {
-      const scrollPosition = window.scrollY
-      const closest = snapPoints.reduce((prev, curr, index) => {
-        return Math.abs(curr - scrollPosition) < Math.abs(snapPoints[prev] - scrollPosition) 
-          ? index 
-          : prev
-      }, 0)
-      setCurrentSnap(closest)
-    }
-
-    window.addEventListener('scroll', handleScroll)
-    return () => window.removeEventListener('scroll', handleScroll)
-  }, [snapPoints])
-
-  const scrollToSnap = (index: number) => {
-    if (index >= 0 && index < snapPoints.length) {
-      window.scrollTo({
-        top: snapPoints[index],
-        behavior: 'smooth'
-      })
-    }
-  }
-
-  return { currentSnap, scrollToSnap }
-}

package/src/use-subscription.ts

@@ -1,37 +0,0 @@
-import { useSession } from "next-auth/react";
-
-export function useSubscription() {
-  const { data: session, status } = useSession();
-
-  const isLoading = status === "loading";
-  const isAuthenticated = status === "authenticated";
-  
-  // Admin kullanıcılar her zaman pro erişime sahip
-  const isAdmin = session?.user?.role === "admin";
-  
-  // Pro abonelik kontrolü
-  const hasProAccess = isAdmin || session?.user?.subscription?.status === "active";
-  const subscriptionPlan = session?.user?.subscription?.plan || (isAdmin ? "lifetime" : "free");
-  
-  // Debug bilgisi
-  if (process.env.NODE_ENV === 'development') {
-    console.log('🔍 useSubscription Debug:', {
-      email: session?.user?.email,
-      role: session?.user?.role,
-      isAdmin,
-      subscription: session?.user?.subscription,
-      hasProAccess,
-      subscriptionPlan,
-      status
-    });
-  }
-  
-  return {
-    isLoading,
-    isAuthenticated,
-    isAdmin,
-    hasProAccess,
-    subscriptionPlan,
-    subscription: session?.user?.subscription,
-  };
-}

package/src/use-toast.ts

@@ -1,32 +0,0 @@
-// Toast hook - şimdilik basit bir implementasyon
-// Gerçek implementasyonda Toaster component'i ile entegre olacak
-
-interface ToastOptions {
-  title: string;
-  description?: string;
-  variant?: 'default' | 'destructive';
-}
-
-export function toast(options: ToastOptions) {
-  // Şimdilik console'a yazdıralım
-  // Gerçek implementasyonda toast notification gösterilecek
-  console.log('Toast:', options);
-  
-  // Browser'da alert gösterelim (geçici çözüm)
-  if (typeof window !== 'undefined') {
-    const message = options.description 
-      ? `${options.title}\n\n${options.description}`
-      : options.title;
-    
-    // Variant'a göre stil belirle
-    if (options.variant === 'destructive') {
-      console.error(message);
-    } else {
-      console.log(message);
-    }
-  }
-}
-
-export const useToast = () => {
-  return { toast };
-};