@raxonltd/raxon-core 1.0.0

package/dist/core/component/general.image.d.ts

@@ -0,0 +1,25 @@
+interface GeneralImageProps {
+    src?: string;
+    alt: string;
+    width?: number;
+    height?: number;
+    className?: string;
+    fill?: boolean;
+    aspectRatio?: string;
+    style?: React.CSSProperties;
+    wrapperClassName?: string;
+    sizes?: string;
+    priority?: boolean;
+    quality?: number;
+    placeholder?: 'blur' | 'empty';
+    blurDataURL?: string;
+    onLoad?: () => void;
+    onError?: () => void;
+    loading?: 'lazy' | 'eager';
+    fetchPriority?: 'low' | 'high';
+    objectFit?: 'contain' | 'cover' | 'fill' | 'none' | 'scale-down';
+    fallback?: 'placeholder' | 'hide' | 'error';
+}
+declare const GeneralImage: (props: GeneralImageProps) => import("react").JSX.Element;
+export { GeneralImage };
+//# sourceMappingURL=general.image.d.ts.map

package/dist/core/component/general.image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"general.image.d.ts","sourceRoot":"","sources":["../../../core/component/general.image.tsx"],"names":[],"mappings":"AAKA,UAAU,iBAAiB;IACzB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IAEZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;IAC5B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;IAC3B,aAAa,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IAC/B,SAAS,CAAC,EAAE,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,YAAY,CAAC;IACjE,QAAQ,CAAC,EAAE,aAAa,GAAG,MAAM,GAAG,OAAO,CAAC;CAC7C;AAED,QAAA,MAAM,YAAY,GAAI,OAAO,iBAAiB,gCAsD7C,CAAC;AAEF,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/core/component/general.image.js

@@ -0,0 +1,30 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import Image from 'next/image';
+const GeneralImage = (props) => {
+    // Placeholder image URL
+    const placeholderImage = 'https://placehold.co/600x400';
+    const [isLoading, setIsLoading] = useState(true);
+    if (!props.src) {
+        return null;
+    }
+    let mageData = (_jsxs(_Fragment, { children: [isLoading && (_jsx("div", { className: "absolute inset-0 flex items-center justify-center bg-gray-100", children: _jsx("div", { className: "animate-spin rounded-full h-8 w-8 border-b-2 border-gray-900" }) })), _jsx(Image, { placeholder: "empty", src: props.src, alt: props.alt, fill: props.fill, style: {
+                    ...props.style,
+                    opacity: isLoading ? 0 : 1,
+                    transition: 'opacity 0.3s ease-in-out'
+                }, className: props.className, width: props.width, height: props.height, priority: props.priority, quality: props.quality ?? 80, objectFit: props.objectFit, fetchPriority: props.fetchPriority, onLoad: () => {
+                    setIsLoading(false);
+                    props.onLoad?.();
+                }, onError: () => {
+                    setIsLoading(false);
+                    props.onError?.();
+                } })] }));
+    if (props.aspectRatio) {
+        return (_jsx(_Fragment, { children: _jsx("div", { className: `aspect-[${props.aspectRatio}] ${props.wrapperClassName}`, children: mageData }) }));
+    }
+    else {
+        return mageData;
+    }
+};
+export { GeneralImage };

package/dist/core/context/cart.context.d.ts

@@ -0,0 +1,25 @@
+import { BasketSummaryInterface } from '@/core/interface/basket.interface';
+import { PromoCode } from '@/core/interface/prisma.interface';
+interface CartContextType {
+    cart: BasketSummaryInterface | null;
+    cartLoading: boolean;
+    isAddingToCart: boolean;
+    isUpdatingCart: boolean;
+    isProductAdding: (productId: string | number, variantId?: string | number | null) => boolean;
+    addToCart: (productId: string | number, quantity: number, variantId?: string | number, options?: {
+        linePay?: number;
+    }) => void;
+    updateQuantity: (itemId: string | number, quantity: number, productId?: string) => void;
+    changeQuantity: (itemId: string | number, delta: number, productId?: string, variantId?: string | number | null) => void;
+    removeItem: (itemId: string | number) => void;
+    cartTotal: number;
+    promoCode: PromoCode | null;
+    setPromoCode: (promoCode: PromoCode | null) => void;
+}
+export declare const CartContext: import("react").Context<CartContextType>;
+export declare const CartProvider: ({ children }: {
+    children: React.ReactNode;
+}) => import("react").JSX.Element;
+export declare const useCartContext: () => CartContextType;
+export {};
+//# sourceMappingURL=cart.context.d.ts.map

package/dist/core/context/cart.context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cart.context.d.ts","sourceRoot":"","sources":["../../../core/context/cart.context.tsx"],"names":[],"mappings":"AAOA,OAAO,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAC3E,OAAO,EAAE,SAAS,EAAE,MAAM,mCAAmC,CAAC;AAiC9D,UAAU,eAAe;IACvB,IAAI,EAAE,sBAAsB,GAAG,IAAI,CAAC;IACpC,WAAW,EAAE,OAAO,CAAC;IACrB,cAAc,EAAE,OAAO,CAAC;IACxB,cAAc,EAAE,OAAO,CAAC;IACxB,eAAe,EAAE,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,KAAK,OAAO,CAAC;IAC7F,SAAS,EAAE,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAC;IAC/H,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACxF,cAAc,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;IACzH,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,KAAK,IAAI,CAAC;IAC9C,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,SAAS,GAAG,IAAI,CAAC;IAC5B,YAAY,EAAE,CAAC,SAAS,EAAE,SAAS,GAAG,IAAI,KAAK,IAAI,CAAC;CACrD;AAED,eAAO,MAAM,WAAW,0CAAwD,CAAC;AAEjF,eAAO,MAAM,YAAY,GAAI,cAAc;IAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,gCA6YvE,CAAC;AAEF,eAAO,MAAM,cAAc,uBAM1B,CAAC"}

package/dist/core/context/cart.context.js

@@ -0,0 +1,339 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useMemo, useRef, useState } from 'react';
+import { useQueryClient } from '@tanstack/react-query';
+import { useCart } from '@/core/feature/cart/hook/use.cart';
+import { useSecurity } from '@/core/context/security.context';
+import toast from 'react-hot-toast';
+import { applyPendingAdds, applyPendingQuantities, cartLineKey, CART_QUANTITY_DEBOUNCE_MS, createEmptyOptimisticCart, extractBasketFromInsertResponse, extractInsertCartItem, findCartLine, applyBasketInsertResponse, mergeInsertItemIntoCart, patchCartCache, patchCartItemQuantity, readCartCache, removeCartLineByKey, } from '@/core/feature/cart/util/cart-optimistic';
+export const CartContext = createContext(undefined);
+export const CartProvider = ({ children }) => {
+    const { isAuthenticated } = useSecurity();
+    const queryClient = useQueryClient();
+    const [promoCode, setPromoCode] = useState(null);
+    const [pendingQuantities, setPendingQuantities] = useState({});
+    const [pendingAdds, setPendingAdds] = useState({});
+    const [addingKeys, setAddingKeys] = useState({});
+    const pendingUpdatesRef = useRef(new Map());
+    const debounceTimersRef = useRef(new Map());
+    const pendingAddsRef = useRef({});
+    const pendingQuantitiesRef = useRef({});
+    const insertQueueRef = useRef(Promise.resolve());
+    const cancelledInsertKeysRef = useRef(new Set());
+    const displayCartRef = useRef(null);
+    const cartHook = useCart();
+    const { data: cart, isLoading: cartLoading } = cartHook.fetch({
+        isEnabled: isAuthenticated,
+    });
+    const insertMutation = cartHook.insert();
+    const updateItemMutation = cartHook.updateItem();
+    const removeMutation = cartHook.remove();
+    const isUpdatingCart = updateItemMutation.isPending || removeMutation.isPending;
+    const isAddingToCart = Object.keys(addingKeys).length > 0 || insertMutation.isPending;
+    const serverCart = useMemo(() => readCartCache(queryClient) ?? cart, [cart, queryClient]);
+    const displayCart = useMemo(() => {
+        if (!serverCart && Object.keys(pendingAdds).length === 0)
+            return null;
+        const base = serverCart ?? createEmptyOptimisticCart();
+        let result = base;
+        if (Object.keys(pendingAdds).length > 0) {
+            result = applyPendingAdds(result, pendingAdds);
+        }
+        if (Object.keys(pendingQuantities).length > 0) {
+            result = applyPendingQuantities(result, pendingQuantities);
+        }
+        return result;
+    }, [serverCart, pendingAdds, pendingQuantities]);
+    displayCartRef.current = displayCart;
+    useEffect(() => {
+        pendingAddsRef.current = pendingAdds;
+    }, [pendingAdds]);
+    useEffect(() => {
+        pendingQuantitiesRef.current = pendingQuantities;
+    }, [pendingQuantities]);
+    useEffect(() => {
+        if (!cart)
+            return;
+        if (cart.promoCode?.id) {
+            setPromoCode((prev) => (prev?.id === cart.promoCode?.id ? prev : cart.promoCode));
+            return;
+        }
+        if (!cart.promoCode?.id) {
+            setPromoCode(null);
+        }
+    }, [cart?.promoCode?.id, cart?.promoCode?.code]);
+    useEffect(() => {
+        return () => {
+            debounceTimersRef.current.forEach((timer) => clearTimeout(timer));
+            debounceTimersRef.current.clear();
+        };
+    }, []);
+    const isProductAdding = (productId, variantId) => {
+        return Boolean(addingKeys[cartLineKey(productId, variantId)]);
+    };
+    const setAdding = (key, value) => {
+        setAddingKeys((prev) => {
+            if (value)
+                return { ...prev, [key]: true };
+            if (!(key in prev))
+                return prev;
+            const next = { ...prev };
+            delete next[key];
+            return next;
+        });
+    };
+    const applyLocalQuantity = (itemId, quantity) => {
+        setPendingQuantities((prev) => {
+            const next = { ...prev, [itemId]: quantity };
+            pendingQuantitiesRef.current = next;
+            return next;
+        });
+    };
+    const getLineQuantity = (itemId) => {
+        if (itemId in pendingQuantitiesRef.current) {
+            return Number(pendingQuantitiesRef.current[itemId]);
+        }
+        if (itemId.startsWith('optimistic-')) {
+            const key = itemId.replace('optimistic-', '');
+            const add = pendingAddsRef.current[key];
+            if (add)
+                return Number(add.quantity);
+        }
+        const item = displayCartRef.current?.items?.find((line) => String(line.id) === itemId);
+        return Number(item?.quantity || 0);
+    };
+    const clearPendingQuantity = (itemId) => {
+        setPendingQuantities((prev) => {
+            if (!(itemId in prev))
+                return prev;
+            const next = { ...prev };
+            delete next[itemId];
+            return next;
+        });
+        pendingUpdatesRef.current.delete(itemId);
+        const timer = debounceTimersRef.current.get(itemId);
+        if (timer) {
+            clearTimeout(timer);
+            debounceTimersRef.current.delete(itemId);
+        }
+    };
+    const flushQuantityUpdate = (itemId) => {
+        const pending = pendingUpdatesRef.current.get(itemId);
+        if (!pending)
+            return;
+        pendingUpdatesRef.current.delete(itemId);
+        debounceTimersRef.current.delete(itemId);
+        updateItemMutation.mutate({ id: itemId, quantity: pending.quantity, productId: pending.productId }, {
+            onSuccess: (data) => {
+                patchCartCache(queryClient, (old) => applyBasketInsertResponse(data, old));
+                if (!pendingUpdatesRef.current.has(itemId)) {
+                    setPendingQuantities((prev) => {
+                        if (!(itemId in prev))
+                            return prev;
+                        const next = { ...prev };
+                        delete next[itemId];
+                        return next;
+                    });
+                }
+            },
+            onError: (error) => {
+                queryClient.invalidateQueries({ queryKey: ['organization', 'cart'] });
+                setPendingQuantities((prev) => {
+                    if (!(itemId in prev))
+                        return prev;
+                    const next = { ...prev };
+                    delete next[itemId];
+                    return next;
+                });
+                toast.error(error?.response?.data?.info?.message || 'Hata oluştu');
+            },
+        });
+    };
+    const applyInsertSuccess = (response, key, productId) => {
+        if (cancelledInsertKeysRef.current.has(key)) {
+            cancelledInsertKeysRef.current.delete(key);
+            const insertItem = extractInsertCartItem(response);
+            if (insertItem?.id) {
+                removeMutation.mutate(insertItem.id);
+            }
+            return;
+        }
+        const pendingAdd = pendingAddsRef.current[key];
+        const pendingQuantity = pendingAdd?.quantity ?? 1;
+        const basket = extractBasketFromInsertResponse(response);
+        const insertItem = extractInsertCartItem(response);
+        if (basket) {
+            patchCartCache(queryClient, (old) => applyBasketInsertResponse(basket, old));
+        }
+        else if (insertItem) {
+            patchCartCache(queryClient, (old) => {
+                const base = old ?? createEmptyOptimisticCart();
+                return mergeInsertItemIntoCart(base, insertItem, pendingAdd ? { ...pendingAdd, quantity: pendingQuantity } : undefined);
+            });
+        }
+        else {
+            queryClient.invalidateQueries({ queryKey: ['organization', 'cart'] });
+        }
+        if (insertItem || basket) {
+            const updatedCart = readCartCache(queryClient);
+            if (findCartLine(updatedCart, productId, pendingAdd?.variantId)) {
+                setPendingAdds((prev) => {
+                    if (!(key in prev))
+                        return prev;
+                    const next = { ...prev };
+                    delete next[key];
+                    pendingAddsRef.current = next;
+                    return next;
+                });
+            }
+        }
+        if (insertItem && pendingQuantity > insertItem.quantity) {
+            updateItemMutation.mutate({ id: insertItem.id, quantity: pendingQuantity, productId: String(productId) }, {
+                onSuccess: (data) => {
+                    patchCartCache(queryClient, (old) => applyBasketInsertResponse(data, old));
+                },
+            });
+        }
+    };
+    const enqueueInsert = (payload, key) => {
+        setAdding(key, true);
+        insertQueueRef.current = insertQueueRef.current
+            .then(() => insertMutation.mutateAsync(payload))
+            .then((response) => {
+            applyInsertSuccess(response, key, payload.productId);
+        })
+            .catch((error) => {
+            setPendingAdds((prev) => {
+                if (!(key in prev))
+                    return prev;
+                const next = { ...prev };
+                delete next[key];
+                pendingAddsRef.current = next;
+                return next;
+            });
+            patchCartCache(queryClient, (old) => {
+                const base = old ?? createEmptyOptimisticCart();
+                return removeCartLineByKey(base, key);
+            });
+            queryClient.invalidateQueries({ queryKey: ['organization', 'cart'] });
+            toast.error(error?.response?.data?.info?.message || 'Sepete eklenirken bir hata oluştu');
+        })
+            .finally(() => {
+            setAdding(key, false);
+        });
+    };
+    const addToCart = (productId, quantity, variantId, options) => {
+        const key = cartLineKey(productId, variantId);
+        const existing = findCartLine(displayCart, productId, variantId);
+        if (existing) {
+            changeQuantity(existing.id, quantity, String(productId), variantId);
+            return;
+        }
+        const pendingAdd = {
+            productId: String(productId),
+            variantId: variantId != null ? String(variantId) : undefined,
+            quantity,
+            linePay: options?.linePay,
+        };
+        const nextPending = { ...pendingAddsRef.current, [key]: pendingAdd };
+        pendingAddsRef.current = nextPending;
+        setPendingAdds(nextPending);
+        patchCartCache(queryClient, (old) => {
+            const base = old ?? createEmptyOptimisticCart();
+            return applyPendingAdds(base, { [key]: pendingAdd });
+        });
+        enqueueInsert({
+            productId,
+            quantity,
+            variantId,
+            type: 'increment',
+            deposit: 'disable',
+            linePay: options?.linePay,
+        }, key);
+    };
+    const updateQuantity = (itemId, quantity, productId, variantId) => {
+        const id = itemId.toString();
+        if (quantity < 1)
+            return;
+        if (id.startsWith('optimistic-')) {
+            const key = id.replace('optimistic-', '');
+            const currentAdd = pendingAddsRef.current[key];
+            if (!currentAdd)
+                return;
+            const nextAdd = { ...currentAdd, quantity };
+            const nextPending = { ...pendingAddsRef.current, [key]: nextAdd };
+            pendingAddsRef.current = nextPending;
+            setPendingAdds(nextPending);
+            patchCartCache(queryClient, (old) => {
+                const base = old ?? createEmptyOptimisticCart();
+                return applyPendingAdds(base, { [key]: nextAdd });
+            });
+            return;
+        }
+        applyLocalQuantity(id, quantity);
+        patchCartCache(queryClient, (old) => {
+            const base = old ?? createEmptyOptimisticCart();
+            return patchCartItemQuantity(base, id, quantity, productId, variantId);
+        });
+        pendingUpdatesRef.current.set(id, { quantity, productId });
+        const existingTimer = debounceTimersRef.current.get(id);
+        if (existingTimer)
+            clearTimeout(existingTimer);
+        debounceTimersRef.current.set(id, setTimeout(() => flushQuantityUpdate(id), CART_QUANTITY_DEBOUNCE_MS));
+    };
+    const changeQuantity = (itemId, delta, productId, variantId) => {
+        const id = itemId.toString();
+        const nextQuantity = getLineQuantity(id) + delta;
+        if (nextQuantity < 1) {
+            removeItem(id);
+            return;
+        }
+        updateQuantity(id, nextQuantity, productId, variantId);
+    };
+    const removeItem = (itemId) => {
+        const id = itemId.toString();
+        clearPendingQuantity(id);
+        if (id.startsWith('optimistic-')) {
+            const key = id.replace('optimistic-', '');
+            cancelledInsertKeysRef.current.add(key);
+            setPendingAdds((prev) => {
+                if (!(key in prev))
+                    return prev;
+                const next = { ...prev };
+                delete next[key];
+                return next;
+            });
+            setAdding(key, false);
+            return;
+        }
+        removeMutation.mutate(id, {
+            onSuccess: () => {
+                toast.success('Ürün sepetten çıkarıldı');
+            },
+            onError: (error) => {
+                toast.error(error?.response?.data?.info?.message || 'Silinirken hata oluştu');
+            },
+        });
+    };
+    return (_jsx(CartContext.Provider, { value: {
+            cart: displayCart,
+            cartLoading,
+            isAddingToCart,
+            isUpdatingCart,
+            isProductAdding,
+            addToCart,
+            updateQuantity,
+            changeQuantity,
+            removeItem,
+            cartTotal: displayCart?.info?.payPrice?.pay || 0,
+            promoCode,
+            setPromoCode,
+        }, children: children }));
+};
+export const useCartContext = () => {
+    const context = useContext(CartContext);
+    if (context === undefined) {
+        throw new Error('useCartContext must be used within an CartProvider');
+    }
+    return context;
+};

package/dist/core/context/security.context.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { User } from '@/core/interface/prisma.interface';
+interface SecurityContextType {
+    profile: User | null | undefined;
+    isLoading: boolean;
+    isAuthenticated: boolean;
+    isGuest: boolean;
+}
+interface SecurityProviderProps {
+    children: React.ReactNode;
+}
+export declare const SecurityProvider: React.FC<SecurityProviderProps>;
+export declare const useSecurity: () => SecurityContextType;
+export {};
+//# sourceMappingURL=security.context.d.ts.map

package/dist/core/context/security.context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"security.context.d.ts","sourceRoot":"","sources":["../../../core/context/security.context.tsx"],"names":[],"mappings":"AAEA,OAAO,KAA+E,MAAM,OAAO,CAAC;AAEpG,OAAO,EAAa,IAAI,EAAE,MAAM,mCAAmC,CAAC;AAIpE,UAAU,mBAAmB;IAC3B,OAAO,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,CAAC;IACjC,SAAS,EAAE,OAAO,CAAC;IACnB,eAAe,EAAE,OAAO,CAAC;IACzB,OAAO,EAAE,OAAO,CAAC;CAClB;AAID,UAAU,qBAAqB;IAC7B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED,eAAO,MAAM,gBAAgB,EAAE,KAAK,CAAC,EAAE,CAAC,qBAAqB,CA6I5D,CAAC;AAEF,eAAO,MAAM,WAAW,QAAO,mBAM9B,CAAC"}

package/dist/core/context/security.context.js

@@ -0,0 +1,130 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useState, useCallback, useMemo } from 'react';
+import { useRouter, usePathname } from 'next/navigation';
+import { LoginType } from '@/core/interface/prisma.interface';
+import { useAuth } from '@/core/feature/auth/hook/use.auth';
+import { useProfile } from '@/core/feature/profile/hook/use.profile';
+const SecurityContext = createContext(undefined);
+export const SecurityProvider = ({ children }) => {
+    const router = useRouter();
+    const pathname = usePathname();
+    const [authLoading, setAuthLoading] = useState(true);
+    const [isAuthenticated, setIsAuthenticated] = useState(false);
+    const [isAuthEstablished, setIsAuthEstablished] = useState(false);
+    const { mutate: tokenCheck } = useAuth().token();
+    const { mutate: loginGuest } = useAuth().loginGuest();
+    const profileQuery = useProfile().fetch({ isEnabled: isAuthEstablished && isAuthenticated });
+    const profile = profileQuery.data;
+    const isGuest = useMemo(() => {
+        return profile?.loginType === LoginType.GUEST;
+    }, [profile]);
+    const isInvalidTokenError = (error) => {
+        const status = error?.response?.status;
+        return status === 401 || status === 403;
+    };
+    const isServerAccessError = (error) => {
+        // axios: response yoksa çoğunlukla network/cors/offline; 5xx ise sunucu erişim sorunu
+        const status = error?.response?.status;
+        return !error?.response || (typeof status === 'number' && status >= 500);
+    };
+    const ensureGuestLogin = useCallback(() => {
+        loginGuest(undefined, {
+            onSuccess: () => {
+                setIsAuthEstablished(true);
+                setIsAuthenticated(true);
+                setAuthLoading(false);
+            },
+            onError: () => {
+                setIsAuthEstablished(false);
+                setIsAuthenticated(false);
+                setAuthLoading(false);
+            },
+        });
+    }, [loginGuest]);
+    const checkToken = useCallback(() => {
+        if (typeof window !== 'undefined') {
+            const token = localStorage.getItem('koksal-token');
+            if (token && token.trim() !== "" && token.length > 3) {
+                setAuthLoading(true);
+                tokenCheck(undefined, {
+                    onSuccess: () => {
+                        setIsAuthEstablished(true);
+                        setIsAuthenticated(true);
+                        setAuthLoading(false);
+                    },
+                    onError: (error) => {
+                        // Sunucu erişim sorunu varsa token silme
+                        if (isServerAccessError(error)) {
+                            setIsAuthEstablished(true);
+                            setIsAuthenticated(true);
+                            setAuthLoading(false);
+                            return;
+                        }
+                        // Token geçersizse misafir girişe düş
+                        if (isInvalidTokenError(error)) {
+                            localStorage.removeItem('koksal-token');
+                            ensureGuestLogin();
+                            return;
+                        }
+                        // Diğer hatalarda da token silmeden misafir girişe düş
+                        ensureGuestLogin();
+                    }
+                });
+            }
+            else {
+                setAuthLoading(true);
+                ensureGuestLogin();
+            }
+        }
+    }, [tokenCheck, ensureGuestLogin]);
+    useEffect(() => {
+        checkToken();
+    }, [checkToken]);
+    useEffect(() => {
+        if (typeof window !== 'undefined') {
+            const handleStorageChange = (e) => {
+                if (e.key === 'koksal-token') {
+                    checkToken();
+                }
+            };
+            // localStorage değişikliklerini dinle
+            window.addEventListener('storage', handleStorageChange);
+            // Aynı tab içindeki localStorage değişikliklerini dinlemek için custom event
+            const handleCustomStorageChange = () => {
+                checkToken();
+            };
+            window.addEventListener('koksal-token-changed', handleCustomStorageChange);
+            return () => {
+                window.removeEventListener('storage', handleStorageChange);
+                window.removeEventListener('koksal-token-changed', handleCustomStorageChange);
+            };
+        }
+    }, [checkToken]);
+    useEffect(() => {
+        // Loading durumunda yönlendirme yapma
+        const isLoading = authLoading || (isAuthEstablished && (profileQuery.isLoading || profileQuery.isFetching));
+        if (isLoading)
+            return;
+        if (pathname.startsWith('/guvenlik') && isAuthenticated && profile?.loginType !== LoginType.GUEST) {
+            router.push('/hesabim');
+        }
+        if (pathname.startsWith('/hesabim') && (!isAuthenticated || profile?.loginType === LoginType.GUEST)) {
+            router.push('/guvenlik/giris-yap');
+        }
+    }, [pathname, isAuthenticated, authLoading, isAuthEstablished, profileQuery.isLoading, profileQuery.isFetching, router]);
+    const isLoading = authLoading || (isAuthEstablished && (profileQuery.isLoading || profileQuery.isFetching));
+    return (_jsx(SecurityContext.Provider, { value: {
+            profile,
+            isLoading,
+            isAuthenticated,
+            isGuest,
+        }, children: children }));
+};
+export const useSecurity = () => {
+    const context = useContext(SecurityContext);
+    if (context === undefined) {
+        throw new Error('useSecurity must be used within an SecurityProvider');
+    }
+    return context;
+};

package/dist/core/feature/address/form/address-search-input.d.ts

@@ -0,0 +1,17 @@
+import { GooglePlacePrediction } from '@/core/feature/address/util/address.types';
+interface AddressSearchInputProps {
+    query: string;
+    onQueryChange: (value: string) => void;
+    results: GooglePlacePrediction[];
+    isSearching: boolean;
+    showResults: boolean;
+    onShowResultsChange: (show: boolean) => void;
+    onSelect: (placeId: string) => void;
+    error?: string;
+    label?: string;
+    placeholder: string;
+    noResultsText: string;
+}
+export declare function AddressSearchInput({ query, onQueryChange, results, isSearching, showResults, onShowResultsChange, onSelect, error, label, placeholder, noResultsText, }: AddressSearchInputProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=address-search-input.d.ts.map

package/dist/core/feature/address/form/address-search-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"address-search-input.d.ts","sourceRoot":"","sources":["../../../../../core/feature/address/form/address-search-input.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,qBAAqB,EAAE,MAAM,2CAA2C,CAAC;AAElF,UAAU,uBAAuB;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACvC,OAAO,EAAE,qBAAqB,EAAE,CAAC;IACjC,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;IACrB,mBAAmB,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IAC7C,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACpC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,kBAAkB,CAAC,EACjC,KAAK,EACL,aAAa,EACb,OAAO,EACP,WAAW,EACX,WAAW,EACX,mBAAmB,EACnB,QAAQ,EACR,KAAK,EACL,KAAK,EACL,WAAW,EACX,aAAa,GACd,EAAE,uBAAuB,+BA4FzB"}

package/dist/core/feature/address/form/address-search-input.js

@@ -0,0 +1,30 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef } from 'react';
+import { Loader2, MapPin, Search } from 'lucide-react';
+export function AddressSearchInput({ query, onQueryChange, results, isSearching, showResults, onShowResultsChange, onSelect, error, label, placeholder, noResultsText, }) {
+    const containerRef = useRef(null);
+    useEffect(() => {
+        const handleClickOutside = (e) => {
+            if (containerRef.current && !containerRef.current.contains(e.target)) {
+                onShowResultsChange(false);
+            }
+        };
+        document.addEventListener('mousedown', handleClickOutside);
+        return () => document.removeEventListener('mousedown', handleClickOutside);
+    }, [onShowResultsChange]);
+    const handleKeyDown = (e) => {
+        if (e.key === 'Escape') {
+            onShowResultsChange(false);
+        }
+        if (e.key === 'Enter' && results.length > 0) {
+            e.preventDefault();
+            onSelect(results[0].place_id);
+        }
+    };
+    const showDropdown = showResults && query.length >= 3;
+    return (_jsxs("div", { ref: containerRef, className: "relative", children: [label ? (_jsx("label", { htmlFor: "address-search", className: "rizzui-input-label mb-1.5 block text-sm font-medium", children: label })) : null, _jsxs("div", { className: "relative", children: [_jsx("input", { id: "address-search", type: "text", value: query, onChange: e => onQueryChange(e.target.value), onFocus: () => {
+                            if (query.length >= 3 && results.length > 0)
+                                onShowResultsChange(true);
+                        }, onKeyDown: handleKeyDown, placeholder: placeholder, autoComplete: "off", className: `rizzui-input-container peer flex h-12 w-full items-center rounded-xl border bg-white py-2 pl-11 pr-11 text-sm shadow-sm transition-all placeholder:text-gray-400 focus:border-[#CF0A2C] focus:outline-none focus:ring-2 focus:ring-[#CF0A2C]/25 ${error ? 'border-red-400 focus:border-red-400 focus:ring-red-500/20' : 'border-gray-200'}` }), _jsx(Search, { className: "pointer-events-none absolute left-3.5 top-1/2 h-[18px] w-[18px] -translate-y-1/2 text-gray-400" }), isSearching ? (_jsx(Loader2, { className: "absolute right-3.5 top-1/2 h-[18px] w-[18px] -translate-y-1/2 animate-spin text-[#CF0A2C]" })) : null] }), error ? _jsx("p", { className: "mt-2 text-xs text-red-500", children: error }) : null, showDropdown ? (_jsx("div", { className: "absolute z-50 mt-2 w-full overflow-hidden rounded-xl border border-gray-200 bg-white shadow-xl", children: results.length > 0 ? (_jsx("ul", { className: "max-h-64 overflow-y-auto py-1", children: results.map(result => (_jsx("li", { children: _jsx("button", { type: "button", onMouseDown: e => e.preventDefault(), onClick: () => onSelect(result.place_id), className: "w-full px-4 py-3 text-left transition-colors hover:bg-red-50/80 focus:bg-red-50 focus:outline-none", children: _jsxs("div", { className: "flex items-start gap-3", children: [_jsx("div", { className: "mt-0.5 flex h-8 w-8 flex-shrink-0 items-center justify-center rounded-lg bg-gray-100", children: _jsx(MapPin, { className: "h-3.5 w-3.5 text-gray-500" }) }), _jsxs("div", { className: "min-w-0 flex-1", children: [_jsx("p", { className: "truncate text-sm font-medium text-gray-900", children: result.structured_formatting.main_text }), _jsx("p", { className: "mt-0.5 truncate text-xs text-gray-500", children: result.structured_formatting.secondary_text || result.description })] })] }) }) }, result.place_id))) })) : (!isSearching && _jsx("p", { className: "px-4 py-6 text-center text-sm text-gray-500", children: noResultsText })) })) : null] }));
+}

package/dist/core/feature/address/hook/use.addres.d.ts

@@ -0,0 +1,10 @@
+import { IData } from "@/core/interface/nexine.interface";
+import { Address } from "@/core/interface/prisma.interface";
+export declare const useAddress: () => {
+    fetch: () => import("@tanstack/react-query").UseQueryResult<NoInfer<IData<Address>>, Error>;
+    create: () => import("@tanstack/react-query").UseMutationResult<any, Error, any, unknown>;
+    detail: (id: string) => import("@tanstack/react-query").UseQueryResult<NoInfer<Address>, Error>;
+    update: () => import("@tanstack/react-query").UseMutationResult<import("axios").AxiosResponse<any, any, {}>, Error, any, unknown>;
+    delete: () => import("@tanstack/react-query").UseMutationResult<import("axios").AxiosResponse<any, any, {}>, Error, string, unknown>;
+};
+//# sourceMappingURL=use.addres.d.ts.map

package/dist/core/feature/address/hook/use.addres.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use.addres.d.ts","sourceRoot":"","sources":["../../../../../core/feature/address/hook/use.addres.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAC;AAC1D,OAAO,EAAE,OAAO,EAAE,MAAM,mCAAmC,CAAC;AAG5D,eAAO,MAAM,UAAU;;;iBAyBC,MAAM;;;CAgC7B,CAAC"}