@eventlook/sdk 1.4.43 → 1.4.45

package/dist/types/utils/types/shopping-cart.type.d.ts

@@ -2,14 +2,14 @@ import { IPromoCode } from '@utils/types/promo-code.type';
 import { ITicketFormTicket } from '@utils/types/ticket.type';
 import { IEventProductForm } from '@utils/types/product.type';
 import { Dayjs } from 'dayjs';
-import { OrderFeeType } from '@utils/data/order';
+import { ShoppingCartStatus } from '@utils/data/shopping-cart';
 export interface ICalculateShoppingCartDto {
     uuid?: string | null;
     eventId: number;
     tickets?: {
         [eventId: string]: ITicketFormTicket[];
     };
-    promoCodeIds: number[] | null;
+    promoCodeIds?: number[] | null;
     products?: {
         [eventId: string]: IEventProductForm[];
     };
@@ -20,57 +20,59 @@ export interface ICalculateShoppingCartDto {
         branchId: string | null;
         price: number;
     };
-    firstName: string | null;
-    lastName: string | null;
-    email: string | null;
-    phone: string | null;
-    birthdate: Dayjs | null;
-    gender: string | null;
-    paymentMethodOptionId: number | null;
-    paymentMethodId: number | null;
+    firstName?: string | null;
+    lastName?: string | null;
+    email?: string | null;
+    phone?: string | null;
+    birthdate?: Dayjs | null;
+    gender?: string | null;
+    paymentMethodId?: number | null;
+    paymentMethodOptionId?: number | null;
     ticketInsurance?: boolean;
     smsNotification?: boolean;
 }
-export interface IShoppingCart {
-    uuid: string;
+export interface ITicketInsurance {
+    enabled: boolean;
+    price: number;
+    pricePerUnit: number;
+}
+export interface ISmsNotification {
+    enabled: boolean;
+    price: number;
+}
+export interface IShoppingCartDto {
     id: number;
-    serviceFee: number;
-    createdAt: string;
-    updatedAt: string;
-    deletedAt: string | null;
+    uuid: string;
+    eventId: number;
+    status: ShoppingCartStatus;
+    tickets: {
+        [eventId: string]: ITicketFormTicket[];
+    };
+    products: {
+        [eventId: string]: IEventProductForm[];
+    };
     originalPrice: number;
     totalPrice: number;
     ticketsTotalPrice: number;
     ticketProductsTotal: number;
     productsTotalPrice: number;
+    shippingFee: number;
+    serviceFee: number;
+    paymentMethodFee: number;
+    promoCodes: IPromoCode[];
+    email: string | null;
+    phone: string | null;
+    firstName: string | null;
+    lastName: string | null;
+    birthdate: string | null;
+    gender: string | null;
     shipping: {
         shippingMethodId: number | null;
         branchId: string | null;
         price: number;
     };
-    expiryTime: string;
-    promoCodes: IPromoCode[] | null;
-    tickets: {
-        [eventId: string]: ITicketFormTicket[];
-    };
-    products: {
-        [eventId: string]: IEventProductForm[];
-    };
-    firstName: string | null;
-    lastName: string | null;
-    email: string | null;
-    phone: string | null;
-    birthdate: Dayjs | null;
-    gender: string | null;
-    paymentMethodOptionId: number | null;
     paymentMethodId: number | null;
-    paymentMethodFee: number | null;
-    orderFeeValue: number | null;
-    orderFeeType: OrderFeeType | null;
-    shippingFee: number;
-    ticketInsurance?: boolean;
-    ticketInsurancePrice?: number;
-    ticketInsurancePricePerUnit?: number;
-    smsNotification?: boolean;
-    smsNotificationPrice?: number;
+    paymentMethodOptionId: number | null;
+    ticketInsurance: ITicketInsurance;
+    smsNotification: ISmsNotification;
 }

package/dist/types/utils/types/ticket.type.d.ts

@@ -68,7 +68,6 @@ export interface ITicketForm {
     smsNotification: boolean;
     smsNotificationPrice: number;
     iframeCampaignId?: number;
-    promoCode: IPromoCode | null;
     products: {
         [eventId: string]: IEventProductForm[];
     };
@@ -84,7 +83,7 @@ export interface ITicketForm {
     totalFee?: number | null;
     isPaymentVerify: boolean;
 }
-export interface ITicketBody extends Omit<ITicketForm, 'promoCode'> {
+export interface ITicketBody extends ITicketForm {
     promoCodeIds: number[];
 }
 export interface IPaidTicket {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventlook/sdk",
-  "version": "1.4.43",
+  "version": "1.4.45",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "dist/types/index.d.ts",

package/src/form/Payment.tsx

@@ -87,12 +87,10 @@ const Payment: React.FC<Props> = ({ event }) => {
         setValue('promoCodes', [...promoCodes, promo]);
         showSnackbar(res.message);
         setPromoCodeError(null);
-        setValue('promoCode', promo);
         setPromoCode('');
       } catch (err) {
         setPromoCodeError(t('form.validation.promo_code_invalid'));
         console.error(err);
-        setValue('promoCode', null);
       }
     },
     1000,

package/src/form/PaymentOverviewBox.tsx

@@ -1,4 +1,4 @@
-import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import React, { useCallback, useEffect, useMemo, useState } from 'react';
 import { Iconify, Image, TextIconLabel } from '@components';
 import { Box, Divider, Grid, IconButton, Stack, Typography } from '@mui/material';
 import PaymentOverviewCheckbox from '@form/payment/PaymentOverviewCheckbox.tsx';
@@ -16,16 +16,14 @@ import FeeBox from '@form/payment/FeeBox';
 import { IPromoCode } from '@utils/types/promo-code.type';
 import { fCurrency } from '@utils/formatNumber';
 import { IEventProductForm, ISelectedProductVariant } from '@utils/types/product.type';
-import { isEqual } from 'lodash';
 import calendarIcon from '@iconify/icons-carbon/calendar';
 import userIcon from '@iconify/icons-carbon/user';
 import { EventType } from '@utils/data/event';
 import dayjs from 'dayjs';
 import useGlobal from '@hooks/useGlobal.ts';
-import { getCreateShoppingCart, recalculateCart } from '@modules/shopping-cart.ts';
-import { ICalculateShoppingCartDto, IShoppingCart } from '@utils/types/shopping-cart.type.ts';
+import { calculateCart, getCart } from '@modules/shopping-cart.ts';
+import { ICalculateShoppingCartDto, IShoppingCartDto } from '@utils/types/shopping-cart.type.ts';
 import { PromoCodeTypes } from '@utils/data/promo-code.ts';
-import { useFirstRender } from '@hooks/useFirstRender.ts';
 import useActiveEventProducts from '@hooks/data/useActiveEventProducts';
 import useDebounce from '@hooks/useDebounce';
 
@@ -35,9 +33,6 @@ interface Props {
 
 const PaymentOverviewBox: React.FC<Props> = ({ event }) => {
   const { t, lang, options } = useGlobal();
-  const firstRender = useFirstRender();
-  const secondRender = useRef(false);
-  const lastCartRef = useRef<IShoppingCart | null>(null);
   const xs = useResponsive('only', 'xs');
   const md = useResponsive('only', 'md');
   const isMobile = useResponsive('down', 'md');
@@ -139,44 +134,45 @@ const PaymentOverviewBox: React.FC<Props> = ({ event }) => {
 
   const shoppingCartBody = useMemo<ICalculateShoppingCartDto>(
     () => ({
-      uuid: uuid,
+      uuid,
       eventId: event.id,
-      tickets: Object.entries(values.tickets).reduce(
-        (acc, [eventId, items]) => {
-          acc[Number(eventId)] = items
-            .filter((item) => !!item.quantity && !!item.releaseId)
+      tickets: Object.fromEntries(
+        Object.entries(values.tickets).map(([id, items]) => [
+          id,
+          items
+            .filter((item) => item.quantity && item.releaseId)
             .map((item) => ({
-              releaseId: Number(item.releaseId),
-              quantity: Number(item.quantity),
-              price: Number(item.price),
-              itemName: item.itemName,
-              products: item.products,
-              extraFields: item.extraFields,
-              eventTimeslotId: Number(eventTimeslotId) || null,
-            }));
-          return acc;
-        },
-        {} as Record<number, ITicketFormTicket[]>
+              ...item,
+              eventTimeslotId: eventTimeslotId ?? null,
+            })),
+        ])
       ),
-      products: Object.entries(values.products).reduce(
-        (acc, [eventId, items]) => {
-          acc[Number(eventId)] = items.map((item) => ({
-            eventProductVariantId: item.eventProductVariantId,
-            productVariantId: item.productVariantId,
-            quantity: item.quantity,
-            price: item.price,
-            excludedShippingMethodIds: item.excludedShippingMethodIds,
-          }));
-          return acc;
-        },
-        {} as Record<number, IEventProductForm[]>
+      products: Object.fromEntries(
+        Object.entries(values.products).map(([id, items]) => [
+          id,
+          items.map(
+            ({
+              eventProductVariantId,
+              productVariantId,
+              quantity,
+              price,
+              excludedShippingMethodIds,
+            }) => ({
+              eventProductVariantId,
+              productVariantId,
+              quantity,
+              price,
+              excludedShippingMethodIds,
+            })
+          ),
+        ])
       ),
       shipping: {
-        shippingMethodId: shipping?.shippingMethodId ? Number(shipping.shippingMethodId) : null,
-        branchId: shipping?.branchId,
-        price: shipping?.price ? Number(shipping.price) : 0,
+        shippingMethodId: shipping?.shippingMethodId ?? null,
+        branchId: shipping?.branchId ?? null,
+        price: shipping?.price ?? 0,
       },
-      promoCodeIds: promoCodes?.map((p) => p.id) || null,
+      promoCodeIds: promoCodes?.map((p) => p.id) ?? null,
       language: lang,
       firstName,
       lastName,
@@ -184,8 +180,8 @@ const PaymentOverviewBox: React.FC<Props> = ({ event }) => {
       phone,
       birthdate,
       gender,
-      paymentMethodId: paymentMethodId === null ? null : Number(paymentMethodId),
-      paymentMethodOptionId: paymentMethodOptionId === null ? null : Number(paymentMethodOptionId),
+      paymentMethodId: paymentMethodId ? Number(paymentMethodId) : null,
+      paymentMethodOptionId: paymentMethodOptionId ? Number(paymentMethodOptionId) : null,
       ticketInsurance,
       smsNotification,
     }),
@@ -194,9 +190,7 @@ const PaymentOverviewBox: React.FC<Props> = ({ event }) => {
       event.id,
       tickets,
       products,
-      shipping.shippingMethodId,
-      shipping.branchId,
-      shipping.price,
+      shipping,
       promoCodes,
       lang,
       firstName,
@@ -215,13 +209,13 @@ const PaymentOverviewBox: React.FC<Props> = ({ event }) => {
 
   const debouncedShoppingCartBody = useDebounce(shoppingCartBody, 300);
 
-  const setShoppingCartValues = (data: IShoppingCart, recalculate = false) => {
+  const setShoppingCartValues = (data: IShoppingCartDto, recalculate = false) => {
     if (!recalculate) {
       const hasTickets =
         !!data.tickets && typeof data.tickets === 'object' && Object.keys(data.tickets).length > 0;
 
       if (hasTickets) {
-        setValue('tickets', { ...tickets, ...data.tickets });
+        setValue('tickets', data.tickets);
       }
 
       const hasProducts =
@@ -230,7 +224,7 @@ const PaymentOverviewBox: React.FC<Props> = ({ event }) => {
         Object.keys(data.products).length > 0;
 
       if (hasProducts) {
-        setValue('products', { ...products, ...data.products });
+        setValue('products', data.products);
       }
 
       setValue('promoCodes', data.promoCodes || []);
@@ -259,11 +253,11 @@ const PaymentOverviewBox: React.FC<Props> = ({ event }) => {
     setValue('totalFee', feeTotal);
 
     setShippingFee(data.shippingFee);
-    setValue('ticketInsurance', data.ticketInsurance || false);
-    setValue('ticketInsurancePrice', data.ticketInsurancePrice || 0);
-    setValue('ticketInsurancePricePerUnit', data.ticketInsurancePricePerUnit || 0);
-    setValue('smsNotification', data.smsNotification || false);
-    setValue('smsNotificationPrice', data.smsNotificationPrice || 0);
+    setValue('ticketInsurance', data.ticketInsurance.enabled);
+    setValue('ticketInsurancePrice', data.ticketInsurance.price);
+    setValue('ticketInsurancePricePerUnit', data.ticketInsurance.pricePerUnit);
+    setValue('smsNotification', data.smsNotification.enabled);
+    setValue('smsNotificationPrice', data.smsNotification.price);
   };
 
   const totalItemCount = useMemo(() => {
@@ -335,30 +329,16 @@ const PaymentOverviewBox: React.FC<Props> = ({ event }) => {
     return discount;
   }, [promoCodes, flatTickets, flatProducts]);
 
-  useEffect(() => {
-    if (!secondRender.current) {
-      secondRender.current = true;
-    } else {
-      return;
-    }
-
-    (async () => {
-      const existing = localStorage.getItem('cartToken');
-      const res = await getCreateShoppingCart(existing, event.id);
-      const data: IShoppingCart = res.data;
-
-      localStorage.setItem('cartToken', data.uuid);
-      setShoppingCartValues(data);
-    })();
+  const hasOrderId = useMemo(() => {
+    const urlParams = new URLSearchParams(window.location.search);
+    return urlParams.has('id');
   }, []);
 
   useEffect(() => {
-    if (firstRender) {
-      return;
+    if (!hasOrderId) {
+      recalculateItems(debouncedShoppingCartBody);
     }
-
-    recalculateItems(debouncedShoppingCartBody);
-  }, [debouncedShoppingCartBody]);
+  }, [debouncedShoppingCartBody, hasOrderId]);
 
   /** Iframe code **/
   useEffect(() => {
@@ -378,27 +358,30 @@ const PaymentOverviewBox: React.FC<Props> = ({ event }) => {
   };
   /** End Iframe code **/
 
-  const updateCartIfChanged = (newCart: IShoppingCart, recalculate = false) => {
-    if (isEqual(lastCartRef.current, newCart)) {
-      return;
-    }
-
-    lastCartRef.current = newCart;
-    setShoppingCartValues(newCart, recalculate);
-  };
-
   const recalculateItems = useCallback(async (body: ICalculateShoppingCartDto) => {
-    const { uuid } = body;
-    if (!uuid) return;
     try {
-      const response = await recalculateCart(body);
-      const cart = response?.data?.data;
+      const isInitial = !body.uuid;
+
+      let response: any;
+      if (isInitial) {
+        const existing = localStorage.getItem('cartToken');
+        const storedUuid =
+          existing && existing !== 'undefined' && existing !== 'null' ? existing : null;
+        response = await getCart(body.eventId, storedUuid);
+      } else {
+        response = await calculateCart(body);
+      }
+
+      const cart = response?.data;
 
       if (cart) {
-        updateCartIfChanged(cart, true);
+        if (cart.uuid) {
+          localStorage.setItem('cartToken', cart.uuid);
+        }
+        setShoppingCartValues(cart, !isInitial);
       }
     } catch (err) {
-      console.error('Error recalculating cart:', err);
+      console.error('Error calculating cart:', err);
     }
   }, []);
 

package/src/form/TicketForm.tsx

@@ -220,7 +220,6 @@ const TicketForm: React.FC<Props> = ({
       smsNotification: false,
       smsNotificationPrice: 0,
       iframeCampaignId: undefined,
-      promoCode: null,
       promoCodes: [],
       products: {},
       shipping: {
@@ -327,6 +326,7 @@ const TicketForm: React.FC<Props> = ({
     } else {
       try {
         const data: ITicketBody = cloneObject(values);
+        data.paymentMethodId = Number(values.paymentMethodId);
         data.promoCodeIds = values.promoCodes?.map((item) => item.id);
         const urlParams = new URLSearchParams(window.location.search);
         const iframeCallback = urlParams.get('callback');
@@ -350,6 +350,7 @@ const TicketForm: React.FC<Props> = ({
           {} as Record<number, ITicketFormTicket[]>
         );
         const { data: orderData } = await postOrder(data);
+        localStorage.removeItem('cartToken');
         const items = [
           ...orderData.tickets.map((ticket) => ({
             item_id: ticket.number,

package/src/form/TicketSelection.tsx

@@ -1,4 +1,4 @@
-import React, { useEffect, useState } from 'react';
+import React, { useEffect, useRef, useState } from 'react';
 import { useFormContext, useWatch } from 'react-hook-form';
 import {
   Box,
@@ -39,6 +39,7 @@ const TicketSelection: React.FC<Props> = ({ event }) => {
   }) as ITicketFormTicket[];
   const eventTimeslotId = watch('eventTimeslotId');
   const [soldOutReleaseCategoryNames, setSoldOutReleaseCategoryNames] = useState<string[]>([]);
+  const isProcessingRef = useRef(false);
   const { data: activeReleases, mutate } = useEventActiveReleases(
     event.id,
     false,
@@ -48,8 +49,8 @@ const TicketSelection: React.FC<Props> = ({ event }) => {
   const showLoading = !activeReleases && event.type !== EventType.RECURRING;
 
   useEffect(() => {
-    selectedTickets();
-  }, [tickets]);
+    if (!isProcessingRef.current) selectedTickets();
+  }, [tickets, activeReleases]);
 
   const isReleaseSelected = (id: number) => !!tickets.find((ticket) => ticket.releaseId === id);
 
@@ -92,7 +93,7 @@ const TicketSelection: React.FC<Props> = ({ event }) => {
     const lockedSelectedReleases: boolean[] | undefined = releases?.map((item, index) => {
       const nextRelease = releases?.find(
         (item2) =>
-          item2.releaseCategoryName === item.releaseCategoryName && item2.order === item.order++
+          item2.releaseCategoryName === item.releaseCategoryName && item2.order === item.order + 1
       );
       const selected = tickets.find((ticket) => ticket.releaseId === item.id);
       return !!nextRelease && item.locked && !!selected && index + 1 == tickets.length;
@@ -139,7 +140,11 @@ const TicketSelection: React.FC<Props> = ({ event }) => {
       soldOutReleaseCategories?.map((item) => item.releaseCategoryName) || []
     );
 
-    if (
+    const hasSelectableRelease = activeReleases?.some(
+      (release) => !isReleaseSelected(release.id) && !release.locked
+    );
+
+    const shouldAddRow =
       (soldOutReleaseCategories &&
         selectedReleaseIsSoldOut(releases) &&
         tickets.length < soldOutReleaseCategories.length + countUnlockedReleases() &&
@@ -149,8 +154,16 @@ const TicketSelection: React.FC<Props> = ({ event }) => {
         activeReleases?.length > tickets.length &&
         tickets.length < soldOutReleaseCategories.length + countUnlockedReleases() &&
         !allFilled.length) ||
-      (tickets.length < countReleaseCategories() && !allFilled.length)
-    ) {
+      (tickets.length < countReleaseCategories() && !allFilled.length);
+
+    const shouldRemoveEmptyRows =
+      allFilled.length > 0 &&
+      tickets.length > 1 &&
+      !hasSelectableRelease &&
+      (!soldOutReleaseCategories?.length || !selectedReleaseIsSoldOut(releases));
+
+    if (shouldAddRow) {
+      isProcessingRef.current = true;
       setValue(`tickets.${event.id}`, [
         ...tickets,
         {
@@ -162,6 +175,15 @@ const TicketSelection: React.FC<Props> = ({ event }) => {
           extraFields: [],
         },
       ]);
+      setTimeout(() => (isProcessingRef.current = false), 0);
+    } else if (shouldRemoveEmptyRows) {
+      // Only remove completely empty rows (no releaseId), keep rows where user started selecting
+      const nonEmptyTickets = tickets.filter((item) => item.releaseId);
+      if (nonEmptyTickets.length < tickets.length) {
+        isProcessingRef.current = true;
+        setValue(`tickets.${event.id}`, nonEmptyTickets);
+        setTimeout(() => (isProcessingRef.current = false), 0);
+      }
     }
   };
 

package/src/form/TicketWithMerchandiseSelection.tsx

@@ -1,4 +1,4 @@
-import React, { useEffect, useMemo, useRef } from 'react';
+import React, { useEffect, useRef } from 'react';
 import { useFormContext, useWatch } from 'react-hook-form';
 import { Box, Divider, Skeleton, Stack, Typography } from '@mui/material';
 import { ITicketForm, ITicketFormTicket } from '@utils/types/ticket.type';
@@ -22,6 +22,7 @@ const TicketWithMerchandiseSelection: React.FC<Props> = ({ event }) => {
   const { setValue, watch } = useFormContext<ITicketForm>();
   const tickets: ITicketFormTicket[] = useWatch({ name: `tickets.${event.id}`, defaultValue: [] });
   const eventTimeslotId = watch('eventTimeslotId');
+  const isProcessingRef = useRef(false);
   const { data: activeReleases, mutate } = useEventActiveReleases(
     event.id,
     false,
@@ -29,8 +30,8 @@ const TicketWithMerchandiseSelection: React.FC<Props> = ({ event }) => {
   );
 
   useEffect(() => {
-    selectedTickets();
-  }, [tickets]);
+    if (!isProcessingRef.current) selectedTickets();
+  }, [tickets, activeReleases]);
 
   const countReleaseCategories = (): number => {
     const grouped = groupBy(activeReleases || [], 'releaseCategoryName');
@@ -41,7 +42,7 @@ const TicketWithMerchandiseSelection: React.FC<Props> = ({ event }) => {
     const lockedSelectedReleases: boolean[] | undefined = releases?.map((item, index) => {
       const nextRelease = releases?.find(
         (item2) =>
-          item2.releaseCategoryName === item.releaseCategoryName && item2.order === item.order++
+          item2.releaseCategoryName === item.releaseCategoryName && item2.order === item.order + 1
       );
       const selected = tickets.find((ticket) => ticket.releaseId === item.id);
       return !!nextRelease && item.locked && !!selected && index + 1 == tickets.length;
@@ -51,6 +52,8 @@ const TicketWithMerchandiseSelection: React.FC<Props> = ({ event }) => {
 
   const countUnlockedReleases = () => activeReleases?.filter((item) => !item.locked).length || 0;
 
+  const isReleaseSelected = (id: number) => !!tickets.find((ticket) => ticket.releaseId === id);
+
   const selectedTickets = async () => {
     const releases = await mutate();
     const allFilled = tickets.filter((item) => !item.releaseId || !item.quantity);
@@ -64,7 +67,34 @@ const TicketWithMerchandiseSelection: React.FC<Props> = ({ event }) => {
       )
     );
 
-    if (
+    // Unlock next releases when current release is sold out
+    if (soldOutReleaseCategories?.length && activeReleases) {
+      let hasChanges = false;
+      const updatedReleases = activeReleases.map((release) => {
+        // For each sold-out release, find and unlock the next one
+        const soldOutRelease = soldOutReleaseCategories.find(
+          (soldOut) =>
+            soldOut.releaseCategoryName === release.releaseCategoryName &&
+            soldOut.order === release.order - 1 &&
+            release.locked
+        );
+        if (soldOutRelease) {
+          hasChanges = true;
+          return { ...release, locked: false };
+        }
+        return release;
+      });
+
+      if (hasChanges) {
+        await mutate(updatedReleases, false);
+      }
+    }
+
+    const hasSelectableRelease = activeReleases?.some(
+      (release) => !isReleaseSelected(release.id) && !release.locked
+    );
+
+    const shouldAddRow =
       (soldOutReleaseCategories &&
         selectedReleaseIsSoldOut(releases) &&
         tickets.length < soldOutReleaseCategories.length + countUnlockedReleases() &&
@@ -74,8 +104,16 @@ const TicketWithMerchandiseSelection: React.FC<Props> = ({ event }) => {
         activeReleases?.length > tickets.length &&
         tickets.length < soldOutReleaseCategories.length + countUnlockedReleases() &&
         !allFilled.length) ||
-      (tickets.length < countReleaseCategories() && !allFilled.length)
-    ) {
+      (tickets.length < countReleaseCategories() && !allFilled.length);
+
+    const shouldRemoveEmptyRows =
+      allFilled.length > 0 &&
+      tickets.length > 1 &&
+      !hasSelectableRelease &&
+      (!soldOutReleaseCategories?.length || !selectedReleaseIsSoldOut(releases));
+
+    if (shouldAddRow) {
+      isProcessingRef.current = true;
       setValue(`tickets.${event.id}`, [
         ...tickets,
         {
@@ -87,6 +125,15 @@ const TicketWithMerchandiseSelection: React.FC<Props> = ({ event }) => {
           extraFields: [],
         },
       ]);
+      setTimeout(() => (isProcessingRef.current = false), 0);
+    } else if (shouldRemoveEmptyRows) {
+      // Only remove completely empty rows (no releaseId), keep rows where user started selecting
+      const nonEmptyTickets = tickets.filter((item) => item.releaseId);
+      if (nonEmptyTickets.length < tickets.length) {
+        isProcessingRef.current = true;
+        setValue(`tickets.${event.id}`, nonEmptyTickets);
+        setTimeout(() => (isProcessingRef.current = false), 0);
+      }
     }
   };
 

package/src/form/payment/FeeBox.tsx

@@ -1,7 +1,6 @@
 import React from 'react';
 import { Box, Stack, Tooltip, Typography } from '@mui/material';
-import { OrderFeeType } from '@utils/data/order';
-import { fCurrency, fPercent } from '@utils/formatNumber';
+import { fCurrency } from '@utils/formatNumber';
 import { Iconify } from '@components/iconify';
 import { IEvent } from '@utils/types/event.type';
 import useResponsive from '@hooks/useResponsive';
@@ -23,7 +22,7 @@ const FeeBox: React.FC<Props> = ({ event, align = 'left' }) => {
 
   return (
     <Box mb={1} textAlign={isRight ? 'right' : undefined}>
-      {values.promoCode && (
+      {values.promoCodes.length > 0 && (
         <Stack
           direction="row"
           justifyContent={isRight ? 'flex-end' : 'space-between'}

package/src/locales/cs.tsx

@@ -61,6 +61,9 @@ const cs = {
       invalid_date: 'Datum není platné.',
       terms_and_conditions: 'Musíte souhlasit s obchodními podmínkami.',
       promo_code_invalid: 'Slevový kód není platný.',
+      promo_code_applied: 'Tento slevový kód již byl použit.',
+      promo_code_cant_combine: 'Tento slevový kód nelze kombinovat s jinými kódy.',
+      min_purchase_not_met: 'Minimální částka nákupu nebyla dosažena: ',
       count_tickets_or_products: 'Musíte vybrat alespoň 1 vstupenku nebo produkt.',
     },
   },

package/src/locales/en.tsx

@@ -61,6 +61,9 @@ const en = {
       invalid_date: 'Date is not valid.',
       terms_and_conditions: 'You must agree to the terms and conditions.',
       promo_code_invalid: 'Promo code is not valid.',
+      promo_code_applied: 'This promo code has already been applied.',
+      promo_code_cant_combine: 'This promo code cannot be combined with other codes.',
+      min_purchase_not_met: 'Minimum purchase amount not met: ',
       count_tickets_or_products: 'You must select at least 1 ticket or product.',
     },
   },