@raxonltd/raxon-core 1.1.6 → 1.1.8

package/core/util/collection.util.ts

@@ -0,0 +1,433 @@
+export function getCollectionLabel(tags?: string[]) {
+
+  const ignored = new Set(['banner', 'subhero', 'web', 'homepage', 'anasayfa']);
+
+  const tag = tags?.find((t) => t && !ignored.has(String(t).toLowerCase()));
+
+  return tag ? String(tag).toUpperCase() : 'KOLEKSİYON';
+
+}
+
+
+
+function normalizeText(value: string) {
+
+  return value
+
+    .toLowerCase()
+
+    .normalize('NFD')
+
+    .replace(/[\u0300-\u036f]/g, '')
+
+    .replace(/ı/g, 'i')
+
+    .replace(/ğ/g, 'g')
+
+    .replace(/ü/g, 'u')
+
+    .replace(/ş/g, 's')
+
+    .replace(/ö/g, 'o')
+
+    .replace(/ç/g, 'c')
+
+    .replace(/[^a-z0-9]+/g, ' ')
+
+    .trim();
+
+}
+
+
+
+function tokensSimilar(a: string, b: string) {
+
+  if (a.length < 4 || b.length < 4) return false;
+
+  const prefixLength = Math.min(6, a.length, b.length);
+
+  const prefixA = a.slice(0, prefixLength);
+
+  const prefixB = b.slice(0, prefixLength);
+
+  return prefixA === prefixB || a.includes(b) || b.includes(a);
+
+}
+
+
+
+export function isBrandCollectionTitle(title: string | undefined) {
+
+  if (!title) return false;
+
+  const normalizedTitle = normalizeText(title);
+
+  return /kesfet|markasinin|marka urun/.test(normalizedTitle);
+
+}
+
+
+
+export function matchDirectBrandIdFromCollectionTitle(
+
+  title: string | undefined,
+
+  brands: Array<{ id: string; name?: string | null }> | undefined
+
+) {
+
+  if (!title || !brands?.length) return null;
+
+
+
+  const normalizedTitle = normalizeText(title);
+
+  if (!normalizedTitle) return null;
+
+
+
+  for (const brand of brands) {
+
+    const brandName = brand.name?.trim();
+
+    if (!brandName) continue;
+
+
+
+    const normalizedBrand = normalizeText(brandName);
+
+    if (normalizedBrand && normalizedTitle === normalizedBrand) {
+
+      return brand.id;
+
+    }
+
+  }
+
+
+
+  return null;
+
+}
+
+
+
+export function matchBrandIdFromCollectionTitle(
+
+  title: string | undefined,
+
+  brands: Array<{ id: string; name?: string | null }> | undefined
+
+) {
+
+  if (!title || !brands?.length) return null;
+
+
+
+  const directBrandId = matchDirectBrandIdFromCollectionTitle(title, brands);
+
+  if (directBrandId) return directBrandId;
+
+
+
+  if (!isBrandCollectionTitle(title)) return null;
+
+
+
+  const normalizedTitle = normalizeText(title);
+
+  if (!normalizedTitle) return null;
+
+
+
+  const titleTokens = normalizedTitle.split(' ').filter((token) => token.length >= 4);
+
+  let bestMatch: { id: string; score: number } | null = null;
+
+
+
+  for (const brand of brands) {
+
+    const brandName = brand.name?.trim();
+
+    if (!brandName) continue;
+
+
+
+    const normalizedBrand = normalizeText(brandName);
+
+    if (!normalizedBrand || normalizedBrand.length < 3) continue;
+
+
+
+    const isMatch =
+
+      tokensSimilar(normalizedTitle, normalizedBrand) ||
+
+      titleTokens.some((token) => tokensSimilar(token, normalizedBrand));
+
+
+
+    if (!isMatch) continue;
+
+
+
+    const score = normalizedBrand.length;
+
+    if (!bestMatch || score > bestMatch.score) {
+
+      bestMatch = { id: brand.id, score };
+
+    }
+
+  }
+
+
+
+  return bestMatch?.id ?? null;
+
+}
+
+
+
+function getCategoryName(category: { name?: unknown } | null | undefined) {
+
+  if (!category?.name) return '';
+
+  if (Array.isArray(category.name)) {
+
+    const first = category.name[0] as { value?: string } | undefined;
+
+    return first?.value || '';
+
+  }
+
+  return String(category.name);
+
+}
+
+
+
+const COLLECTION_CATEGORY_HINTS: Array<{ titlePattern: RegExp; categoryPattern: RegExp }> = [
+
+  { titlePattern: /saclar|sacini|sac bakim/, categoryPattern: /sac bakim urunleri/ },
+
+  { titlePattern: /gunes|tatilde/, categoryPattern: /gunes/ },
+
+  { titlePattern: /makyaj/, categoryPattern: /makyaj urunleri/ },
+
+];
+
+
+
+const COLLECTION_SEARCH_HINTS: Array<{ titlePattern: RegExp; searchQuery: string }> = [
+
+  { titlePattern: /saclar|sacini|sac bakim/, searchQuery: 'sac bakim' },
+
+];
+
+
+
+export function matchSearchQueryFromCollectionTitle(title: string | undefined) {
+
+  if (!title) return null;
+
+
+
+  const normalizedTitle = normalizeText(title);
+
+  if (!normalizedTitle) return null;
+
+
+
+  for (const hint of COLLECTION_SEARCH_HINTS) {
+
+    if (hint.titlePattern.test(normalizedTitle)) {
+
+      return hint.searchQuery;
+
+    }
+
+  }
+
+
+
+  return null;
+
+}
+
+
+
+export function shouldPreferThematicCategoryFallback(title: string | undefined) {
+
+  if (!title) return false;
+
+  const normalizedTitle = normalizeText(title);
+
+  return COLLECTION_CATEGORY_HINTS.some((hint) => hint.titlePattern.test(normalizedTitle));
+
+}
+
+
+
+export function matchCategoryIdFromCollectionTitle(
+
+  title: string | undefined,
+
+  categories: Array<{ id: string; name?: unknown }> | undefined
+
+) {
+
+  if (!title || !categories?.length || !shouldPreferThematicCategoryFallback(title)) return null;
+
+
+
+  const normalizedTitle = normalizeText(title);
+
+  if (!normalizedTitle) return null;
+
+
+
+  for (const hint of COLLECTION_CATEGORY_HINTS) {
+
+    if (!hint.titlePattern.test(normalizedTitle)) continue;
+
+    const match = categories.find((category) =>
+
+      hint.categoryPattern.test(normalizeText(getCategoryName(category)))
+
+    );
+
+    if (match) return match.id;
+
+  }
+
+
+
+  return null;
+
+}
+
+
+
+export type CollectionProductSource = 'collection' | 'detail' | 'brand' | 'category' | 'search' | 'empty';
+
+
+
+const MAX_SANE_COLLECTION_COUNT = 200;
+
+const MIN_COMPLETE_BRAND_COLLECTION_PRODUCTS = 10;
+
+
+
+export function resolveCollectionProductSource(params: {
+
+  apiCount: number;
+
+  detailCount: number;
+
+  title?: string;
+
+  brandId?: string | null;
+
+  categoryId?: string | null;
+
+  searchQuery?: string | null;
+
+  isDirectBrandCollection?: boolean;
+
+  isCollectionProductsSettled: boolean;
+
+}): CollectionProductSource | null {
+
+  const {
+
+    apiCount,
+
+    detailCount,
+
+    title,
+
+    brandId,
+
+    categoryId,
+
+    searchQuery,
+
+    isDirectBrandCollection,
+
+    isCollectionProductsSettled,
+
+  } = params;
+
+
+
+  if (!isCollectionProductsSettled) return null;
+
+
+
+  if (apiCount > 0 && apiCount <= MAX_SANE_COLLECTION_COUNT) {
+
+    if (apiCount < 3 && shouldPreferThematicCategoryFallback(title)) {
+
+      if (searchQuery) return 'search';
+
+      if (categoryId) return 'category';
+
+    }
+
+
+
+    if (
+
+      isDirectBrandCollection &&
+
+      brandId &&
+
+      apiCount < MIN_COMPLETE_BRAND_COLLECTION_PRODUCTS
+
+    ) {
+
+      return 'brand';
+
+    }
+
+
+
+    return 'collection';
+
+  }
+
+
+
+  if (detailCount > 0) return 'detail';
+
+  if (brandId) return 'brand';
+
+  if (searchQuery) return 'search';
+
+  if (categoryId) return 'category';
+
+
+
+  return 'empty';
+
+}
+
+
+
+export function filterProductsByCollectionAllowlist<T extends { id?: string | null }>(
+
+  products: T[],
+
+  allowlistIds: Set<string>
+
+) {
+
+  if (allowlistIds.size === 0) return products;
+
+  return products.filter((product) => product.id && allowlistIds.has(product.id));
+
+}
+
+

package/core/util/fetch.bootstrap.ts

@@ -0,0 +1,21 @@
+import { RaxonBootstrapPayload } from '@/core/interface/bootstrap.interface';
+
+export async function fetchRaxonBootstrap(
+  apiUrl: string,
+  apiKey: string,
+  init?: RequestInit,
+): Promise<RaxonBootstrapPayload> {
+  const response = await fetch(`${apiUrl}/customer/bootstrap`, {
+    ...init,
+    headers: {
+      'x-api-key': apiKey,
+      ...init?.headers,
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(`[RAXON] Bootstrap failed: ${response.status}`);
+  }
+
+  return response.json() as Promise<RaxonBootstrapPayload>;
+}

package/core/util/garanti-payment.ts

@@ -0,0 +1,5 @@
+export {
+  storeGarantiPaymentHtml,
+  consumeGarantiPaymentHtml,
+  submitGarantiPaymentHtml,
+} from '@/core/feature/cart/util/garanti-payment';

package/core/util/nexine.axios.tsx

@@ -0,0 +1,104 @@
+import axios from 'axios';
+import { toast } from 'react-hot-toast';
+
+export const nexineAxios = axios.create({
+  baseURL: typeof window !== 'undefined' ? (window as any).__RAXON_API_URL__ : process.env.NEXT_PUBLIC_API_URL,
+  headers: {
+    'Content-Type': 'application/json',
+    'x-api-key': typeof window !== 'undefined' ? (window as any).__RAXON_API_KEY__ : (process.env.NEXT_PUBLIC_API_KEY || ''),
+  },
+});
+
+const resolveApiKey = (): string => {
+  if (typeof window !== 'undefined') {
+    return (
+      (window as any).__RAXON_API_KEY__ ||
+      (nexineAxios.defaults.headers.common['x-api-key'] as string) ||
+      ''
+    );
+  }
+  return process.env.NEXT_PUBLIC_API_KEY || '';
+};
+
+const resolveApiUrl = (): string | undefined => {
+  if (typeof window !== 'undefined') {
+    return (window as any).__RAXON_API_URL__ || nexineAxios.defaults.baseURL;
+  }
+  return process.env.NEXT_PUBLIC_API_URL;
+};
+
+nexineAxios.interceptors.request.use(config => {
+  const apiKey = resolveApiKey();
+  if (apiKey) {
+    config.headers['x-api-key'] = apiKey;
+  }
+
+  const apiUrl = resolveApiUrl();
+  if (apiUrl) {
+    config.baseURL = apiUrl;
+  }
+
+  if (typeof window !== 'undefined') {
+    const token = localStorage.getItem('koksal-token');
+    if (token) {
+      config.headers.Authorization = `Bearer ${token}`;
+    }
+
+    console.log(document.cookie
+      .split('; ').find(row => row.startsWith('_fbp='))?.split('=')[1])
+
+    const fbc = document.cookie
+      .split('; ')
+      .find(row => row.startsWith('_fbc='))
+      ?.split('=')[1];
+    const fbp = document.cookie
+      .split('; ')
+      .find(row => row.startsWith('_fbp='))
+      ?.split('=')[1];
+
+    if (fbc) {
+      config.headers['x-fbc'] = fbc;
+    }
+    if (fbp) {
+      config.headers['x-fbp'] = fbp;
+    }
+  }
+
+  return config;
+});
+
+nexineAxios.interceptors.response.use(
+  response => {
+    var excludeArray = ['/auth/register'];
+    if (response.config.method != 'get' && response.data.info && response.data.info.message && !excludeArray.includes(response.config.url || '')) {
+      toast.success(response.data.info.message);
+    }
+    return response;
+  },
+  error => {
+    // 401 Unauthorized hatası yakalandığında sadece token'ı temizle
+    if (error.response?.status === 401) {
+      const requestUrl = error.config?.url || '';
+      const requestMethod = error.config?.method || '';
+
+      // Token'ı temizle
+      if (typeof window !== 'undefined') {
+        localStorage.removeItem('koksal-token');
+      }
+
+      // /auth/me endpoint'inde toast gösterme (SecurityContext yönetiyor)
+      if (!requestUrl.includes('/auth/me')) {
+        // Sadece POST, PUT, DELETE işlemlerinde toast göster
+        if (requestMethod !== 'get') {
+          toast.error('Oturum süreniz dolmuş. Lütfen tekrar giriş yapın.');
+        }
+      }
+    }
+
+    if (error.response?.data.info && error.response?.data.info.message) {
+      toast.error(error.response?.data.info.message ?? error.response?.data.info.title );
+    }
+
+    return Promise.reject(error);
+  }
+);

package/core/util/no-cache.ts

@@ -0,0 +1,6 @@
+// API yanıtları için no-cache header'ları
+export const NO_CACHE_HEADERS = {
+  'Cache-Control': 'no-store, no-cache, must-revalidate, proxy-revalidate',
+  'Pragma': 'no-cache',
+  'Expires': '0',
+};