@raxonltd/raxon-core 1.0.0

package/dist/core/feature/address/hook/use.addres.js

@@ -0,0 +1,57 @@
+import { nexineAxios } from "@/core/util/nexine.axios";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+export const useAddress = () => {
+    const queryClient = useQueryClient();
+    return {
+        fetch: () => {
+            return useQuery({
+                queryKey: ['web', 'address'],
+                queryFn: async () => {
+                    var response = await nexineAxios.get('/customer/address');
+                    return response.data;
+                },
+            });
+        },
+        create: () => {
+            return useMutation({
+                mutationFn: async (data) => {
+                    var respose = await nexineAxios.post('/customer/address', data);
+                    return respose.data;
+                },
+                onSuccess: () => {
+                    queryClient.invalidateQueries({ queryKey: ['web', 'address'] });
+                }
+            });
+        },
+        detail: (id) => {
+            return useQuery({
+                queryKey: ['web', 'address', 'detail', id],
+                enabled: !!id && id !== "" && id != "create",
+                queryFn: async () => {
+                    var response = await nexineAxios.get(`/customer/address/${id}`);
+                    return response.data;
+                },
+            });
+        },
+        update: () => {
+            return useMutation({
+                mutationFn: (data) => {
+                    return nexineAxios.put('/customer/address', data);
+                },
+                onSuccess: () => {
+                    queryClient.invalidateQueries({ queryKey: ['web', 'address'] });
+                }
+            });
+        },
+        delete: () => {
+            return useMutation({
+                mutationFn: (id) => {
+                    return nexineAxios.delete(`/customer/address/${id}`);
+                },
+                onSuccess: () => {
+                    queryClient.invalidateQueries({ queryKey: ['web', 'address'] });
+                }
+            });
+        }
+    };
+};

package/dist/core/feature/address/hook/use.address-autocomplete.d.ts

@@ -0,0 +1,13 @@
+import { GooglePlacePrediction } from '@/core/feature/address/util/address.types';
+export declare function useAddressAutocomplete(): {
+    query: string;
+    setQuery: (value: string) => void;
+    onUserQueryChange: (value: string) => void;
+    results: GooglePlacePrediction[];
+    isSearching: boolean;
+    showResults: boolean;
+    setShowResults: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    selectPlace: (prediction: GooglePlacePrediction) => Promise<import("@/core/feature/address/util/address.types").ParsedAddressData>;
+    resetSearch: () => void;
+};
+//# sourceMappingURL=use.address-autocomplete.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use.address-autocomplete.d.ts","sourceRoot":"","sources":["../../../../../core/feature/address/hook/use.address-autocomplete.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,EAAE,MAAM,2CAA2C,CAAC;AAMlF,wBAAgB,sBAAsB;;sBAmG1B,MAAM;+BAKN,MAAM;;;;;8BA5BK,qBAAqB;;EA2C3C"}

package/dist/core/feature/address/hook/use.address-autocomplete.js

@@ -0,0 +1,105 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { parseGooglePlaceResult } from '@/core/feature/address/util/parse-google-place';
+const DEBOUNCE_MS = 400;
+const MIN_QUERY_LENGTH = 3;
+export function useAddressAutocomplete() {
+    const [query, setQuery] = useState('');
+    const [results, setResults] = useState([]);
+    const [isSearching, setIsSearching] = useState(false);
+    const [isSelecting, setIsSelecting] = useState(false);
+    const [showResults, setShowResults] = useState(false);
+    const abortRef = useRef(null);
+    const searchOnChangeRef = useRef(false);
+    const searchAddresses = useCallback(async (input) => {
+        if (!input || input.length < MIN_QUERY_LENGTH) {
+            setResults([]);
+            setShowResults(false);
+            return;
+        }
+        abortRef.current?.abort();
+        const controller = new AbortController();
+        abortRef.current = controller;
+        setIsSearching(true);
+        try {
+            const params = new URLSearchParams({
+                input,
+                components: 'country:tr',
+                language: 'tr',
+            });
+            const response = await fetch(`/api/places/autocomplete?${params}`, {
+                signal: controller.signal,
+            });
+            if (!response.ok)
+                throw new Error('Autocomplete request failed');
+            const data = await response.json();
+            setResults(data.predictions || []);
+            setShowResults(true);
+        }
+        catch (error) {
+            if (error.name !== 'AbortError') {
+                setResults([]);
+            }
+        }
+        finally {
+            setIsSearching(false);
+        }
+    }, []);
+    const setQueryValue = useCallback((value, options) => {
+        const shouldSearch = options?.search ?? false;
+        searchOnChangeRef.current = shouldSearch;
+        setQuery(prev => {
+            if (prev === value) {
+                if (!shouldSearch)
+                    searchOnChangeRef.current = false;
+                return prev;
+            }
+            return value;
+        });
+        if (!shouldSearch) {
+            abortRef.current?.abort();
+            setResults([]);
+            setShowResults(false);
+        }
+    }, []);
+    useEffect(() => {
+        if (!searchOnChangeRef.current)
+            return;
+        const timer = setTimeout(() => {
+            searchAddresses(query);
+            searchOnChangeRef.current = false;
+        }, DEBOUNCE_MS);
+        return () => clearTimeout(timer);
+    }, [query, searchAddresses]);
+    const selectPlace = useCallback(async (prediction) => {
+        setIsSelecting(true);
+        setShowResults(false);
+        try {
+            const response = await fetch(`/api/places/details?place_id=${prediction.place_id}&language=tr`);
+            if (!response.ok)
+                throw new Error('Place details request failed');
+            const data = await response.json();
+            const parsed = parseGooglePlaceResult(data.result);
+            setQueryValue(parsed.formattedAddress, { search: false });
+            return parsed;
+        }
+        finally {
+            setIsSelecting(false);
+        }
+    }, [setQueryValue]);
+    const resetSearch = useCallback(() => {
+        setQueryValue('', { search: false });
+    }, [setQueryValue]);
+    const setQueryProgrammatic = useCallback((value) => setQueryValue(value, { search: false }), [setQueryValue]);
+    const onUserQueryChange = useCallback((value) => setQueryValue(value, { search: true }), [setQueryValue]);
+    return {
+        query,
+        setQuery: setQueryProgrammatic,
+        onUserQueryChange,
+        results,
+        isSearching: isSearching || isSelecting,
+        showResults,
+        setShowResults,
+        selectPlace,
+        resetSearch,
+    };
+}

package/dist/core/feature/address/util/address.types.d.ts

@@ -0,0 +1,37 @@
+export interface GooglePlacePrediction {
+    description: string;
+    place_id: string;
+    structured_formatting: {
+        main_text: string;
+        secondary_text: string;
+    };
+}
+export interface GooglePlaceDetails {
+    geometry: {
+        location: {
+            lat: number;
+            lng: number;
+        };
+    };
+    address_components: Array<{
+        long_name: string;
+        short_name: string;
+        types: string[];
+    }>;
+    formatted_address: string;
+}
+export interface ParsedAddressData {
+    streetNumber: string;
+    streetName: string;
+    neighborhood: string;
+    district: string;
+    city: string;
+    province: string;
+    country: string;
+    countryCode: string;
+    postalCode: string;
+    latitude: number;
+    longitude: number;
+    formattedAddress: string;
+}
+//# sourceMappingURL=address.types.d.ts.map

package/dist/core/feature/address/util/address.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"address.types.d.ts","sourceRoot":"","sources":["../../../../../core/feature/address/util/address.types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,qBAAqB;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,qBAAqB,EAAE;QACrB,SAAS,EAAE,MAAM,CAAC;QAClB,cAAc,EAAE,MAAM,CAAC;KACxB,CAAC;CACH;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE;QACR,QAAQ,EAAE;YACR,GAAG,EAAE,MAAM,CAAC;YACZ,GAAG,EAAE,MAAM,CAAC;SACb,CAAC;KACH,CAAC;IACF,kBAAkB,EAAE,KAAK,CAAC;QACxB,SAAS,EAAE,MAAM,CAAC;QAClB,UAAU,EAAE,MAAM,CAAC;QACnB,KAAK,EAAE,MAAM,EAAE,CAAC;KACjB,CAAC,CAAC;IACH,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,iBAAiB;IAChC,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;CAC1B"}

package/dist/core/feature/address/util/address.types.js

@@ -0,0 +1 @@
+export {};

package/dist/core/feature/address/util/parse-google-place.d.ts

@@ -0,0 +1,13 @@
+import { Address } from '@/core/interface/prisma.interface';
+import { GooglePlaceDetails, ParsedAddressData } from '@/core/feature/address/util/address.types';
+export declare function parseGooglePlaceResult(placeDetails: GooglePlaceDetails): ParsedAddressData;
+export declare function formatAddressSummary(data: Partial<Address> | ParsedAddressData): string;
+export declare function parsedAddressToFormFields(parsed: ParsedAddressData): {
+    street: string;
+    buildingNumber: string;
+    apartmentNumber: string;
+    postalCode: string;
+    provinceName: string;
+    districtName: string;
+};
+//# sourceMappingURL=parse-google-place.d.ts.map

package/dist/core/feature/address/util/parse-google-place.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-google-place.d.ts","sourceRoot":"","sources":["../../../../../core/feature/address/util/parse-google-place.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,mCAAmC,CAAC;AAC5D,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,2CAA2C,CAAC;AAWlG,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,kBAAkB,GAAG,iBAAiB,CAyB1F;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,iBAAiB,GAAG,MAAM,CAYvF;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,iBAAiB;;;;;;;EAYlE"}

package/dist/core/feature/address/util/parse-google-place.js

@@ -0,0 +1,49 @@
+function getAddressComponent(components, types, useShort = false) {
+    const component = components.find(comp => types.some(type => comp.types.includes(type)));
+    return useShort ? component?.short_name || '' : component?.long_name || '';
+}
+export function parseGooglePlaceResult(placeDetails) {
+    const components = placeDetails.address_components;
+    const district = getAddressComponent(components, ['administrative_area_level_2']) ||
+        getAddressComponent(components, ['sublocality_level_1', 'sublocality']);
+    const city = getAddressComponent(components, ['administrative_area_level_1']) ||
+        getAddressComponent(components, ['locality', 'postal_town']);
+    return {
+        streetNumber: getAddressComponent(components, ['street_number']),
+        streetName: getAddressComponent(components, ['route']),
+        neighborhood: getAddressComponent(components, ['neighborhood', 'sublocality_level_1', 'sublocality']),
+        district,
+        city,
+        province: getAddressComponent(components, ['administrative_area_level_1']),
+        country: getAddressComponent(components, ['country']),
+        countryCode: getAddressComponent(components, ['country'], true),
+        postalCode: getAddressComponent(components, ['postal_code']),
+        latitude: placeDetails.geometry.location.lat,
+        longitude: placeDetails.geometry.location.lng,
+        formattedAddress: placeDetails.formatted_address,
+    };
+}
+export function formatAddressSummary(data) {
+    const street = [data.streetName, 'streetNumber' in data ? data.streetNumber : undefined].filter(Boolean).join(' ');
+    const cityLine = [
+        data.postalCode,
+        'city' in data ? data.city || data.province : data.administrativeAreaLevel1,
+        'district' in data ? data.district : data.administrativeAreaLevel2,
+    ]
+        .filter(Boolean)
+        .join(' ');
+    const country = data.country;
+    return [street, cityLine, country].filter(Boolean).join(', ');
+}
+export function parsedAddressToFormFields(parsed) {
+    const streetParts = [parsed.neighborhood, parsed.streetName].filter(Boolean);
+    const street = streetParts.join(', ');
+    return {
+        street: street || parsed.formattedAddress,
+        buildingNumber: parsed.streetNumber,
+        apartmentNumber: '',
+        postalCode: parsed.postalCode,
+        provinceName: parsed.province || parsed.city,
+        districtName: parsed.district,
+    };
+}

package/dist/core/feature/analytic-event/analytic.event.context.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+interface AnalyticEvent {
+    productId: string;
+    variantId?: string | null;
+}
+interface EmailClickedEvent {
+    tcx: string;
+}
+interface AnalyticEventContextType {
+    trackProductView: (event: AnalyticEvent) => void;
+    trackProductClick: (event: AnalyticEvent) => void;
+    trackEmailClicked: (event: EmailClickedEvent) => void;
+}
+export declare const AnalyticEventProvider: ({ children }: {
+    children: React.ReactNode;
+}) => React.JSX.Element;
+export declare const useAnalyticEvent: () => AnalyticEventContextType;
+export {};
+//# sourceMappingURL=analytic.event.context.d.ts.map

package/dist/core/feature/analytic-event/analytic.event.context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analytic.event.context.d.ts","sourceRoot":"","sources":["../../../../core/feature/analytic-event/analytic.event.context.tsx"],"names":[],"mappings":"AACA,OAAO,KAAuD,MAAM,OAAO,CAAC;AAI5E,UAAU,aAAa;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED,UAAU,iBAAiB;IACzB,GAAG,EAAE,MAAM,CAAC;CACb;AAED,UAAU,wBAAwB;IAChC,gBAAgB,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;IACjD,iBAAiB,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;IAClD,iBAAiB,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;CACvD;AAID,eAAO,MAAM,qBAAqB,GAAI,cAAc;IAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,sBAqJhF,CAAC;AAEF,eAAO,MAAM,gBAAgB,gCAM5B,CAAC"}

package/dist/core/feature/analytic-event/analytic.event.context.js

@@ -0,0 +1,151 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useRef } from 'react';
+import { useSearchParams, useRouter } from 'next/navigation';
+import { AnalyticEventType } from '../../interface/prisma.interface';
+const AnalyticEventContext = createContext(undefined);
+export const AnalyticEventProvider = ({ children }) => {
+    const bufferRef = useRef([]);
+    const timeoutRef = useRef(null);
+    const searchParams = useSearchParams();
+    const router = useRouter();
+    const tcxProcessedRef = useRef(false);
+    const flush = async () => {
+        const events = [...bufferRef.current];
+        if (events.length === 0)
+            return;
+        // Send copy, clear original buffer immediately to avoid race conditions if possible
+        // (though in JS single thread it's mostly fine, but async operations...)
+        bufferRef.current = [];
+        try {
+            await fetch('/api/analytic-event', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(events),
+                keepalive: true,
+            });
+        }
+        catch (e) {
+            console.error('Failed to send product events', e);
+        }
+    };
+    const sendEmailClickedEvent = async (tcx) => {
+        try {
+            await fetch('/api/analytic-event', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify([
+                    {
+                        trackingCode: tcx,
+                        eventType: AnalyticEventType.EMAIL_CLICKED,
+                    },
+                ]),
+                keepalive: true,
+            });
+            // İşlem tamamlandıktan sonra URL'den tcx parametresini kaldır
+            removeTcxFromUrl();
+        }
+        catch (e) {
+            console.error('Failed to send email clicked event', e);
+        }
+    };
+    const removeTcxFromUrl = () => {
+        const currentUrl = new URL(window.location.href);
+        if (currentUrl.searchParams.has('tcx')) {
+            currentUrl.searchParams.delete('tcx');
+            router.replace(currentUrl.pathname + currentUrl.search, { scroll: false });
+        }
+    };
+    const trackProductView = (event) => {
+        if (!event.productId)
+            return;
+        // Avoid duplicates in the current pending batch
+        const exists = bufferRef.current.some(e => e.productId === event.productId && e.variantId === event.variantId);
+        if (!exists) {
+            bufferRef.current.push(event);
+        }
+        if (!timeoutRef.current) {
+            timeoutRef.current = setTimeout(() => {
+                flush();
+                timeoutRef.current = null;
+            }, 2000);
+        }
+    };
+    const trackProductClick = (event) => {
+        if (!event.productId)
+            return;
+        fetch('/api/analytic-event', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify([
+                {
+                    productId: event.productId,
+                    variantId: event.variantId,
+                    eventType: AnalyticEventType.CLICKED,
+                },
+            ]),
+            keepalive: true,
+        }).catch((e) => {
+            console.error('Failed to send product click event', e);
+        });
+    };
+    const trackEmailClicked = (event) => {
+        if (!event.tcx)
+            return;
+        sendEmailClickedEvent(event.tcx);
+    };
+    // İlk sayfa yüklendiğinde tcx parametresini kontrol et
+    useEffect(() => {
+        if (tcxProcessedRef.current)
+            return;
+        const tcx = searchParams.get('tcx');
+        if (tcx) {
+            tcxProcessedRef.current = true;
+            trackEmailClicked({ tcx });
+        }
+    }, [searchParams]);
+    useEffect(() => {
+        const handleUnload = () => {
+            if (timeoutRef.current) {
+                clearTimeout(timeoutRef.current);
+                timeoutRef.current = null;
+            }
+            flush();
+        };
+        const handleVisibilityChange = () => {
+            if (document.visibilityState === 'hidden') {
+                // If user switches tab, maybe flush?
+                // User asked for "session end" or "2s".
+                // Visibility hidden is good practice to ensure data is saved.
+                // But if they come back, we just start a new batch.
+                // Let's keep the timeout if it's running, but flush if tab is closing/hiding?
+                // Actually, if we flush on hidden, we might send partial batches more often than 2s if user switches tabs a lot.
+                // But better safe than sorry for analytics.
+                handleUnload();
+            }
+        };
+        window.addEventListener('beforeunload', handleUnload);
+        document.addEventListener('visibilitychange', handleVisibilityChange);
+        return () => {
+            window.removeEventListener('beforeunload', handleUnload);
+            document.removeEventListener('visibilitychange', handleVisibilityChange);
+            if (timeoutRef.current) {
+                clearTimeout(timeoutRef.current);
+            }
+        };
+    }, []);
+    return _jsx(AnalyticEventContext.Provider, { value: { trackProductView, trackProductClick, trackEmailClicked }, children: children });
+};
+export const useAnalyticEvent = () => {
+    const context = useContext(AnalyticEventContext);
+    if (!context) {
+        throw new Error('useAnalyticEvent must be used within a AnalyticEventProvider');
+    }
+    return context;
+};

package/dist/core/feature/article/hook/use.article.d.ts

@@ -0,0 +1,7 @@
+import { IData } from "@/core/interface/nexine.interface";
+import { Article } from "@/core/interface/prisma.interface";
+export declare const useArticle: () => {
+    fetch: (params?: any) => import("@tanstack/react-query").UseQueryResult<NoInfer<IData<Article>>, Error>;
+    detail: (id: string) => import("@tanstack/react-query").UseQueryResult<NoInfer<Article>, Error>;
+};
+//# sourceMappingURL=use.article.d.ts.map

package/dist/core/feature/article/hook/use.article.d.ts.map

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

package/dist/core/feature/article/hook/use.article.js

@@ -0,0 +1,28 @@
+import { nexineAxios } from "@/core/util/nexine.axios";
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+export const useArticle = () => {
+    const queryClient = useQueryClient();
+    return {
+        fetch: (params) => {
+            return useQuery({
+                queryKey: ['web', 'article', params],
+                queryFn: async () => {
+                    var response = await nexineAxios.get('/customer/article', {
+                        params
+                    });
+                    return response.data;
+                },
+            });
+        },
+        detail: (id) => {
+            return useQuery({
+                queryKey: ['web', 'article', id],
+                queryFn: async () => {
+                    var response = await nexineAxios.get('/customer/article/' + id);
+                    return response.data;
+                },
+                enabled: Boolean(id),
+            });
+        }
+    };
+};

package/dist/core/feature/attribute/hook/use.attribute.d.ts

@@ -0,0 +1,10 @@
+import { IData } from '@/core/interface/nexine.interface';
+import { Attribute } from '@/core/interface/prisma.interface';
+export declare const useAttribute: () => {
+    fetch: (params: {
+        categoryId?: string;
+        enabled?: boolean;
+        productId?: string;
+    }) => import("@tanstack/react-query").UseQueryResult<NoInfer<IData<Attribute>>, Error>;
+};
+//# sourceMappingURL=use.attribute.d.ts.map

package/dist/core/feature/attribute/hook/use.attribute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use.attribute.d.ts","sourceRoot":"","sources":["../../../../../core/feature/attribute/hook/use.attribute.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAC;AAC1D,OAAO,EAAE,SAAS,EAAwB,MAAM,mCAAmC,CAAC;AAGpF,eAAO,MAAM,YAAY;oBAEL;QAAE,UAAU,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE;CAgBjF,CAAC"}

package/dist/core/feature/attribute/hook/use.attribute.js

@@ -0,0 +1,21 @@
+import { nexineAxios } from '@/core/util/nexine.axios';
+import { useQuery } from '@tanstack/react-query';
+export const useAttribute = () => {
+    return {
+        fetch: (params) => {
+            return useQuery({
+                queryKey: ['attribute', 'category', params.categoryId, params.productId],
+                enabled: (params.enabled ?? true),
+                queryFn: async () => {
+                    var response = await nexineAxios.get('/customer/attribute', {
+                        params: {
+                            categoryId: params.categoryId,
+                            productId: params.productId,
+                        },
+                    });
+                    return response.data;
+                },
+            });
+        },
+    };
+};

package/dist/core/feature/auth/hook/use.auth.d.ts

@@ -0,0 +1,29 @@
+export declare const LOGOUT_EVENT = "intermarkt-logout";
+export declare const LOGIN_SUCCESS_EVENT = "intermarkt-login-success";
+export declare const useAuth: () => {
+    profile: ({ isEnabled }: {
+        isEnabled?: boolean;
+    }) => import("@tanstack/react-query").UseQueryResult<any, Error>;
+    token: () => import("@tanstack/react-query").UseMutationResult<any, Error, void, unknown>;
+    loginEmail: () => import("@tanstack/react-query").UseMutationResult<any, Error, any, unknown>;
+    loginGuest: () => import("@tanstack/react-query").UseMutationResult<any, Error, void, unknown>;
+    loginSocial: () => import("@tanstack/react-query").UseMutationResult<any, Error, {
+        platform: string;
+        returnUrl?: string;
+    }, unknown>;
+    register: () => import("@tanstack/react-query").UseMutationResult<import("axios").AxiosResponse<any, any, {}>, Error, any, unknown>;
+    codeSend: () => import("@tanstack/react-query").UseMutationResult<import("axios").AxiosResponse<any, any, {}>, Error, {
+        email: string;
+    }, unknown>;
+    verifyCode: () => import("@tanstack/react-query").UseMutationResult<import("axios").AxiosResponse<any, any, {}>, Error, {
+        email: string;
+        code: string;
+    }, unknown>;
+    resetPassword: () => import("@tanstack/react-query").UseMutationResult<import("axios").AxiosResponse<any, any, {}>, Error, {
+        email: string;
+        code: string;
+        password: string;
+    }, unknown>;
+    logout: () => void;
+};
+//# sourceMappingURL=use.auth.d.ts.map

package/dist/core/feature/auth/hook/use.auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use.auth.d.ts","sourceRoot":"","sources":["../../../../../core/feature/auth/hook/use.auth.tsx"],"names":[],"mappings":"AAMA,eAAO,MAAM,YAAY,sBAAsB,CAAC;AAChD,eAAO,MAAM,mBAAmB,6BAA6B,CAAC;AAE9D,eAAO,MAAM,OAAO;;;;;;;;kBAoEiC,MAAM;oBAAc,MAAM;;;;eAmBnC,MAAM;;;eAWN,MAAM;cAAQ,MAAM;;;eAYpB,MAAM;cAAQ,MAAM;kBAAY,MAAM;;;CAqBjF,CAAC"}