@ticketboothapp/booking 1.2.123 → 1.2.125

package/src/components/booking/useAdminCustomReceiptLines.ts

@@ -0,0 +1,57 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+
+export type AdminCustomReceiptLine = {
+  id: string;
+  label: string;
+  amountInput: string;
+  amountSign: 1 | -1;
+};
+
+type AdminCustomReceiptLinePatch = Partial<
+  Pick<AdminCustomReceiptLine, 'label' | 'amountInput' | 'amountSign'>
+>;
+
+export function useAdminCustomReceiptLines(resetKey: string | null | undefined) {
+  const [adminCustomReceiptLines, setAdminCustomReceiptLines] = useState<AdminCustomReceiptLine[]>([]);
+  const adminCustomLineIdRef = useRef(0);
+  const previousResetKeyRef = useRef(resetKey);
+
+  const handleAddAdminCustomReceiptLine = useCallback(() => {
+    adminCustomLineIdRef.current += 1;
+    setAdminCustomReceiptLines((prev) => [
+      ...prev,
+      {
+        id: `admin-rcpt-${adminCustomLineIdRef.current}`,
+        label: '',
+        amountInput: '',
+        amountSign: 1,
+      },
+    ]);
+  }, []);
+
+  const handleUpdateAdminCustomReceiptLine = useCallback(
+    (id: string, patch: AdminCustomReceiptLinePatch) => {
+      setAdminCustomReceiptLines((prev) =>
+        prev.map((line) => (line.id === id ? { ...line, ...patch } : line))
+      );
+    },
+    [],
+  );
+
+  const handleRemoveAdminCustomReceiptLine = useCallback((id: string) => {
+    setAdminCustomReceiptLines((prev) => prev.filter((line) => line.id !== id));
+  }, []);
+
+  useEffect(() => {
+    if (previousResetKeyRef.current === resetKey) return;
+    previousResetKeyRef.current = resetKey;
+    setAdminCustomReceiptLines([]);
+  }, [resetKey]);
+
+  return {
+    adminCustomReceiptLines,
+    handleAddAdminCustomReceiptLine,
+    handleUpdateAdminCustomReceiptLine,
+    handleRemoveAdminCustomReceiptLine,
+  };
+}

package/src/components/booking/useAdminProviderPricingAdjustments.ts

@@ -0,0 +1,146 @@
+import { useMemo } from 'react';
+import { roundMoney } from '../../lib/booking/change-flow-pricing';
+import type {
+  ProviderDashboardChangePricingUi,
+  ProviderDashboardPricingLine,
+} from './booking-flow-ui';
+import type { ProviderDashboardChangeBookingPayload } from './provider-dashboard-change-booking';
+
+type AdminCustomReceiptLine = { label: string; amountInput: string; amountSign?: number };
+type ProviderLineOverride = NonNullable<
+  NonNullable<ProviderDashboardChangeBookingPayload['pricingAdjustment']>['lineOverrides']
+>[number];
+type ProviderAdditionalAdjustment = NonNullable<
+  NonNullable<ProviderDashboardChangeBookingPayload['pricingAdjustment']>['additionalAdjustments']
+>[number];
+
+export interface UseAdminProviderPricingAdjustmentsParams {
+  isProviderDashboardChange: boolean;
+  showProviderPricingInlineEditor: boolean;
+  providerPricingUi?: ProviderDashboardChangePricingUi;
+  providerQuotedLines: ProviderDashboardPricingLine[];
+  hasChangeSelection: boolean;
+  editableSummaryPreSubtotalDelta: number;
+  adminCustomAdjustmentTotal: number;
+  adminCustomReceiptLines: AdminCustomReceiptLine[];
+  isManualOverrideEligibleLine: (line: ProviderDashboardPricingLine) => boolean;
+}
+
+function parseProviderLineAmount(raw: string | undefined, fallbackAmount: number): number | null {
+  const parsed = raw == null || raw.trim() === '' ? fallbackAmount : Number(raw);
+  if (!Number.isFinite(parsed)) return null;
+  return Math.round(parsed * 100) / 100;
+}
+
+export function useAdminProviderPricingAdjustments({
+  isProviderDashboardChange,
+  showProviderPricingInlineEditor,
+  providerPricingUi,
+  providerQuotedLines,
+  hasChangeSelection,
+  editableSummaryPreSubtotalDelta,
+  adminCustomAdjustmentTotal,
+  adminCustomReceiptLines,
+  isManualOverrideEligibleLine,
+}: UseAdminProviderPricingAdjustmentsParams) {
+  const providerTotalsPreview =
+    showProviderPricingInlineEditor && providerPricingUi?.totalsPreview
+      ? providerPricingUi.totalsPreview
+      : null;
+
+  const providerPricingOverrides = useMemo(
+    (): ProviderLineOverride[] =>
+      isProviderDashboardChange && providerQuotedLines.length > 0
+        ? providerQuotedLines
+            .filter((line) => isManualOverrideEligibleLine(line))
+            .map((line): ProviderLineOverride | null => {
+              const rounded = parseProviderLineAmount(
+                providerPricingUi?.lineAmountInputs?.[line.lineKey],
+                line.amount,
+              );
+              return rounded != null && Math.abs(rounded - line.amount) > 0.0001
+                ? { lineKey: line.lineKey, amount: rounded, reason: 'Provider dashboard override' }
+                : null;
+            })
+            .filter((v): v is ProviderLineOverride => v != null)
+        : [],
+    [
+      isProviderDashboardChange,
+      providerQuotedLines,
+      providerPricingUi?.lineAmountInputs,
+      isManualOverrideEligibleLine,
+    ],
+  );
+
+  const providerHasAdditionalAdjustments = useMemo(
+    () =>
+      isProviderDashboardChange &&
+      (providerPricingUi?.additionalAdjustments ?? []).some((adj) => {
+        const parsed = Number((adj.amountInput ?? '').trim());
+        const hasAmount = Number.isFinite(parsed) && parsed > 0;
+        const currentAmount = hasAmount ? (Math.round(parsed * 100) / 100).toFixed(2) : '';
+        const originalAmount = adj.originalAmountInput ?? '';
+        const currentLabel = (adj.label ?? '').trim();
+        const originalLabel = (adj.originalLabel ?? '').trim();
+        const currentMode = adj.mode;
+        const originalMode = adj.originalMode;
+        if (!originalMode) return hasAmount || currentLabel.length > 0;
+        return currentAmount !== originalAmount || currentLabel !== originalLabel || currentMode !== originalMode;
+      }),
+    [isProviderDashboardChange, providerPricingUi?.additionalAdjustments],
+  );
+
+  const providerAdditionalAdjustments = useMemo(
+    (): ProviderAdditionalAdjustment[] =>
+      isProviderDashboardChange
+        ? (providerPricingUi?.additionalAdjustments ?? [])
+            .map((adj): ProviderAdditionalAdjustment | null => {
+              const parsed = Number((adj.amountInput ?? '').trim());
+              if (!Number.isFinite(parsed) || parsed <= 0) return null;
+              const rounded = Math.round(parsed * 100) / 100;
+              const signed = adj.mode === 'DISCOUNT' ? -rounded : rounded;
+              return {
+                label: adj.label?.trim() || (signed < 0 ? 'Provider discount' : 'Provider charge'),
+                amount: signed,
+              };
+            })
+            .filter((v): v is ProviderAdditionalAdjustment => v != null)
+        : [],
+    [isProviderDashboardChange, providerPricingUi?.additionalAdjustments],
+  );
+
+  const adminCustomLinesAsAdditionalAdjustments = useMemo(
+    (): ProviderAdditionalAdjustment[] =>
+      adminCustomReceiptLines.flatMap((line) => {
+        const raw = line.amountInput.trim();
+        if (raw === '' || raw === '+' || raw === '-') return [];
+        const n = Number(raw);
+        if (!Number.isFinite(n) || Math.abs(n) < 0.0005) return [];
+        const sign = line.amountSign ?? 1;
+        const amount = roundMoney(sign * Math.abs(n));
+        if (Math.abs(amount) < 0.005) return [];
+        return [{ label: line.label.trim() || 'Adjustment', amount }];
+      }),
+    [adminCustomReceiptLines],
+  );
+
+  const mergedProviderAdditionalAdjustments = useMemo(
+    () => [...providerAdditionalAdjustments, ...adminCustomLinesAsAdditionalAdjustments],
+    [providerAdditionalAdjustments, adminCustomLinesAsAdditionalAdjustments],
+  );
+
+  const hasEffectiveChangeSelection =
+    hasChangeSelection ||
+    providerPricingOverrides.length > 0 ||
+    providerHasAdditionalAdjustments ||
+    (isProviderDashboardChange && Math.abs(editableSummaryPreSubtotalDelta) >= 0.005) ||
+    Math.abs(adminCustomAdjustmentTotal) >= 0.005;
+
+  return {
+    providerTotalsPreview,
+    hasEffectiveChangeSelection,
+    providerPricingOverrides,
+    adminCustomLinesAsAdditionalAdjustments,
+    mergedProviderAdditionalAdjustments,
+  };
+}

package/src/components/booking/useBookingAvailabilityAddOns.ts

@@ -0,0 +1,54 @@
+import { useEffect, useMemo, useRef, useState, type Dispatch, type SetStateAction } from 'react';
+import {
+  getAddOns,
+  type AddOn,
+  type Availability,
+} from '../../lib/booking-api';
+import { getAvailabilityOptionId } from './change-booking-flow-helpers';
+
+export interface UseBookingAvailabilityAddOnsParams {
+  selectedAvailability: Availability | null;
+  companyId?: string | null;
+  onProductOptionChange?: () => void;
+}
+
+export interface UseBookingAvailabilityAddOnsResult {
+  addOns: AddOn[];
+  setAddOns: Dispatch<SetStateAction<AddOn[]>>;
+  availabilityProductOptionId: string | null;
+}
+
+export function useBookingAvailabilityAddOns({
+  selectedAvailability,
+  companyId,
+  onProductOptionChange,
+}: UseBookingAvailabilityAddOnsParams): UseBookingAvailabilityAddOnsResult {
+  const [addOns, setAddOns] = useState<AddOn[]>([]);
+  const previousAvailabilityProductOptionIdRef = useRef<string | null>(null);
+  const availabilityProductOptionId = useMemo(
+    () => (selectedAvailability ? getAvailabilityOptionId(selectedAvailability) || null : null),
+    [selectedAvailability],
+  );
+
+  useEffect(() => {
+    if (!availabilityProductOptionId || !companyId) {
+      setAddOns([]);
+      onProductOptionChange?.();
+      return;
+    }
+    const optionChanged = previousAvailabilityProductOptionIdRef.current !== availabilityProductOptionId;
+    if (optionChanged) {
+      onProductOptionChange?.();
+      previousAvailabilityProductOptionIdRef.current = availabilityProductOptionId;
+    }
+    getAddOns(companyId, { productOptionId: availabilityProductOptionId, preCheckout: true })
+      .then(setAddOns)
+      .catch(() => setAddOns([]));
+  }, [availabilityProductOptionId, companyId, onProductOptionChange]);
+
+  return {
+    addOns,
+    setAddOns,
+    availabilityProductOptionId,
+  };
+}

package/src/components/booking/useBookingPromoAndQuantityController.ts

@@ -0,0 +1,163 @@
+import { useCallback, useEffect, useMemo, useRef, useState, type Dispatch, type SetStateAction } from 'react';
+import {
+  validatePromoCode,
+  type Availability,
+} from '../../lib/booking-api';
+import { getAvailabilityOptionId } from './change-booking-flow-helpers';
+
+export interface UseBookingPromoAndQuantityControllerParams {
+  isAdmin: boolean;
+  effectivePartySizeCap: number;
+  currentTotalQuantity: number;
+  quantities: Record<string, number>;
+  setQuantities: Dispatch<SetStateAction<Record<string, number>>>;
+  changeBookingMinimumQuantities?: Record<string, number>;
+  selectedAvailability: Availability | null;
+  totalQuantity: number;
+  promoCodeInput: string;
+  appliedPromoCode: string | null;
+  setAppliedPromoCode: Dispatch<SetStateAction<string | null>>;
+  productCompanyId?: string | null;
+  productId: string;
+  clearFetchedAvailabilityRanges: () => void;
+  t: (key: string) => string;
+  setError: (error: string) => void;
+}
+
+export interface UseBookingPromoAndQuantityControllerResult {
+  handleQuantityChange: (category: string, delta: number) => void;
+  handleApplyPromo: () => Promise<void>;
+}
+
+export function useBookingPromoAndQuantityController({
+  isAdmin,
+  effectivePartySizeCap,
+  currentTotalQuantity,
+  quantities,
+  setQuantities,
+  changeBookingMinimumQuantities,
+  selectedAvailability,
+  totalQuantity,
+  promoCodeInput,
+  appliedPromoCode,
+  setAppliedPromoCode,
+  productCompanyId,
+  productId,
+  clearFetchedAvailabilityRanges,
+  t,
+  setError,
+}: UseBookingPromoAndQuantityControllerParams): UseBookingPromoAndQuantityControllerResult {
+  const [, setPromoCodeError] = useState('');
+  const [, setPromoCodeValidating] = useState(false);
+  const promoAppliedSelectionKeyRef = useRef<string | null>(null);
+  const promoValidateInFlightRef = useRef(false);
+
+  const handleQuantityChange = useCallback((category: string, delta: number) => {
+    const maxAvailable = isAdmin ? Number.MAX_SAFE_INTEGER : effectivePartySizeCap;
+    const currentQty = quantities[category] || 0;
+    const minQ =
+      changeBookingMinimumQuantities != null
+        ? Math.max(0, changeBookingMinimumQuantities[category] ?? 0)
+        : 0;
+    const newQty = Math.max(minQ, currentQty + delta);
+    // Admin can overbook; non-admin cannot exceed vacancies.
+    if (delta > 0 && !isAdmin && currentTotalQuantity >= maxAvailable) {
+      return;
+    }
+    setQuantities((prev) => ({
+      ...prev,
+      [category]: newQty,
+    }));
+    setError('');
+  }, [
+    isAdmin,
+    effectivePartySizeCap,
+    quantities,
+    changeBookingMinimumQuantities,
+    currentTotalQuantity,
+    setQuantities,
+    setError,
+  ]);
+
+  const hasOngoingDiscount = useMemo(
+    () =>
+      selectedAvailability?.rates?.some((r) =>
+        (r.appliedAdjustments ?? r.applied_adjustments ?? []).some((a) => (a.type ?? '').toLowerCase() === 'deal')
+      ) ?? false,
+    [selectedAvailability],
+  );
+
+  const selectedAvailabilityKey = useMemo(
+    () => `${selectedAvailability?.dateTime ?? ''}::${selectedAvailability ? getAvailabilityOptionId(selectedAvailability) : ''}`,
+    [selectedAvailability],
+  );
+
+  const handleApplyPromo = useCallback(async () => {
+    const code = promoCodeInput.trim().toUpperCase();
+    if (!code) return;
+    // Promo validation/application requires a concrete booking context.
+    if (!selectedAvailability || totalQuantity <= 0) {
+      return;
+    }
+    if (appliedPromoCode === code) return;
+    const companyId = productCompanyId;
+    if (!companyId) return;
+    if (promoValidateInFlightRef.current) return;
+    promoValidateInFlightRef.current = true;
+    setPromoCodeError('');
+    setPromoCodeValidating(true);
+    try {
+      const result = await validatePromoCode(code, companyId, productId, hasOngoingDiscount);
+      if (result.valid) {
+        promoAppliedSelectionKeyRef.current = selectedAvailabilityKey;
+        setAppliedPromoCode(code);
+        clearFetchedAvailabilityRanges();
+      } else {
+        const errorMsg =
+          result.error === 'Promo codes cannot be stacked with deals'
+            ? (t('booking.promoCodesCannotStackWithDiscounts') || result.error)
+            : (result.error || t('booking.invalidPromoCode') || 'Invalid or expired promo code');
+        setPromoCodeError(errorMsg);
+      }
+    } catch (err) {
+      setPromoCodeError(err instanceof Error ? err.message : 'Failed to validate promo code');
+    } finally {
+      promoValidateInFlightRef.current = false;
+      setPromoCodeValidating(false);
+    }
+  }, [
+    promoCodeInput,
+    selectedAvailability,
+    totalQuantity,
+    appliedPromoCode,
+    productCompanyId,
+    productId,
+    hasOngoingDiscount,
+    selectedAvailabilityKey,
+    setAppliedPromoCode,
+    clearFetchedAvailabilityRanges,
+    t,
+  ]);
+
+  const handleApplyPromoRef = useRef(handleApplyPromo);
+  handleApplyPromoRef.current = handleApplyPromo;
+
+  // Auto-apply promo when user stops typing; avoid depending on validation state to prevent repeated retries.
+  useEffect(() => {
+    const trimmed = promoCodeInput.trim().toUpperCase();
+    if (!trimmed) return;
+    if (!selectedAvailability || totalQuantity <= 0) return;
+    if (appliedPromoCode === trimmed) return;
+
+    const timer = setTimeout(() => {
+      handleApplyPromoRef.current();
+    }, 600);
+
+    return () => clearTimeout(timer);
+  }, [promoCodeInput, appliedPromoCode, selectedAvailability, totalQuantity]);
+
+  return {
+    handleQuantityChange,
+    handleApplyPromo,
+  };
+}

package/src/components/booking/useBookingQuantityCapTrim.ts

@@ -0,0 +1,56 @@
+import { useEffect, type Dispatch, type SetStateAction } from 'react';
+import type { Availability } from '../../lib/booking-api';
+
+export interface UseBookingQuantityCapTrimParams {
+  isAdmin: boolean;
+  selectedAvailability: Availability | null;
+  effectivePartySizeCap: number;
+  totalQuantity: number;
+  minimumQuantities?: Record<string, number>;
+  setQuantities: Dispatch<SetStateAction<Record<string, number>>>;
+}
+
+export function useBookingQuantityCapTrim({
+  isAdmin,
+  selectedAvailability,
+  effectivePartySizeCap,
+  totalQuantity,
+  minimumQuantities,
+  setQuantities,
+}: UseBookingQuantityCapTrimParams) {
+  useEffect(() => {
+    if (isAdmin || !selectedAvailability) return;
+    const cap = effectivePartySizeCap;
+    if (totalQuantity <= cap) return;
+    const over = totalQuantity - cap;
+    setQuantities((prev) => {
+      const next = { ...prev };
+      let remaining = over;
+      const categories = Object.keys(next)
+        .filter((category) => (next[category] ?? 0) > 0)
+        .sort((a, b) => (next[b] ?? 0) - (next[a] ?? 0));
+
+      for (const category of categories) {
+        if (remaining <= 0) break;
+        const minQuantity =
+          minimumQuantities != null
+            ? Math.max(0, minimumQuantities[category] ?? 0)
+            : 0;
+        const currentQuantity = next[category] ?? 0;
+        const reducible = Math.max(0, currentQuantity - minQuantity);
+        const decrement = Math.min(reducible, remaining);
+        next[category] = currentQuantity - decrement;
+        remaining -= decrement;
+      }
+
+      return next;
+    });
+  }, [
+    effectivePartySizeCap,
+    totalQuantity,
+    selectedAvailability,
+    isAdmin,
+    minimumQuantities,
+    setQuantities,
+  ]);
+}

package/src/components/booking/useBookingViewItemAnalytics.ts

@@ -0,0 +1,30 @@
+import { useEffect, useRef } from 'react';
+import type { Product } from '../../lib/booking-api';
+import type { Currency } from './CurrencySwitcher';
+
+interface BookingViewItemAnalytics {
+  trackViewItem: (id: string, name: string, price: number, currency: Currency) => void;
+}
+
+export function useBookingViewItemAnalytics({
+  analytics,
+  product,
+  productId,
+  currency,
+}: {
+  analytics: BookingViewItemAnalytics;
+  product: Product;
+  productId?: string;
+  currency: Currency;
+}) {
+  const hasFiredViewItem = useRef(false);
+
+  useEffect(() => {
+    if (!hasFiredViewItem.current && product) {
+      hasFiredViewItem.current = true;
+      const id = productId || product.productId;
+      const price = product.minPriceByCurrency?.[currency] ?? 0;
+      analytics.trackViewItem(id, product.name, price, currency);
+    }
+  }, [analytics, product, productId, currency]);
+}

package/src/components/booking/useChangeBookingAddOnFloorController.ts

@@ -0,0 +1,109 @@
+import { useCallback, useMemo, type Dispatch, type SetStateAction } from 'react';
+import type { AddOn } from '../../lib/booking-api';
+import type { ChangeBookingFlowProps } from './booking-flow-types';
+import {
+  deriveAddOnSelectionsFromReceiptLines,
+  normalizeAddOnSelections,
+  type AddOnSelection,
+} from './change-booking-flow-helpers';
+
+type AddOnSelectionsUpdater = AddOnSelection[] | ((prev: AddOnSelection[]) => AddOnSelection[]);
+
+interface UseChangeBookingAddOnFloorControllerOptions {
+  initialValues?: ChangeBookingFlowProps['initialValues'];
+  originalReceiptLineItems?: NonNullable<ChangeBookingFlowProps['originalReceipt']>['lineItems'];
+  addOns: AddOn[];
+  isCustomerSelfServeChange: boolean;
+  setAddOnSelections: Dispatch<SetStateAction<AddOnSelection[]>>;
+}
+
+export function useChangeBookingAddOnFloorController({
+  initialValues,
+  originalReceiptLineItems,
+  addOns,
+  isCustomerSelfServeChange,
+  setAddOnSelections,
+}: UseChangeBookingAddOnFloorControllerOptions): {
+  initialAddOnMinQtyByKey: Map<string, number>;
+  initialAddOnMinTotalByAddOnId: Map<string, number>;
+  updateAddOnSelections: (updater: AddOnSelectionsUpdater) => void;
+} {
+  const initialAddOnBaselineSelections = useMemo(() => {
+    const initialSelections = initialValues?.addOnSelections;
+    if ((initialSelections?.length ?? 0) > 0) {
+      return normalizeAddOnSelections(initialSelections ?? []);
+    }
+    if ((originalReceiptLineItems?.length ?? 0) > 0 && addOns.length > 0) {
+      return normalizeAddOnSelections(deriveAddOnSelectionsFromReceiptLines(addOns, originalReceiptLineItems ?? []));
+    }
+    return [] as AddOnSelection[];
+  }, [initialValues?.addOnSelections, originalReceiptLineItems, addOns]);
+
+  const initialAddOnMinQtyByKey = useMemo(() => {
+    const map = new Map<string, number>();
+    if (!isCustomerSelfServeChange) return map;
+    for (const sel of initialAddOnBaselineSelections) {
+      const key = `${sel.addOnId.trim()}::${sel.variantId?.trim() || ''}`;
+      map.set(key, (map.get(key) ?? 0) + Math.max(1, Number(sel.quantity) || 1));
+    }
+    return map;
+  }, [isCustomerSelfServeChange, initialAddOnBaselineSelections]);
+
+  const initialAddOnMinTotalByAddOnId = useMemo(() => {
+    const map = new Map<string, number>();
+    if (!isCustomerSelfServeChange) return map;
+    for (const sel of initialAddOnBaselineSelections) {
+      const addOnId = sel.addOnId.trim();
+      map.set(addOnId, (map.get(addOnId) ?? 0) + Math.max(1, Number(sel.quantity) || 1));
+    }
+    return map;
+  }, [isCustomerSelfServeChange, initialAddOnBaselineSelections]);
+
+  const applyChangeFlowAddOnFloor = useCallback(
+    (nextSelections: AddOnSelection[]) => {
+      if (!isCustomerSelfServeChange || initialAddOnMinQtyByKey.size === 0) return nextSelections;
+      const qtyByKey = new Map<string, number>();
+      for (const sel of nextSelections) {
+        const key = `${sel.addOnId.trim()}::${sel.variantId?.trim() || ''}`;
+        qtyByKey.set(key, (qtyByKey.get(key) ?? 0) + Math.max(1, Number(sel.quantity) || 1));
+      }
+
+      const totalByAddOnId = new Map<string, number>();
+      for (const [key, qty] of qtyByKey.entries()) {
+        const addOnId = key.split('::')[0];
+        totalByAddOnId.set(addOnId, (totalByAddOnId.get(addOnId) ?? 0) + qty);
+      }
+
+      for (const [addOnId, minTotal] of initialAddOnMinTotalByAddOnId.entries()) {
+        const currentTotal = totalByAddOnId.get(addOnId) ?? 0;
+        if (currentTotal >= minTotal) continue;
+        const deficit = minTotal - currentTotal;
+        const existingKey = Array.from(qtyByKey.keys()).find((k) => k.startsWith(`${addOnId}::`));
+        const targetKey = existingKey ?? `${addOnId}::`;
+        qtyByKey.set(targetKey, (qtyByKey.get(targetKey) ?? 0) + deficit);
+      }
+      return Array.from(qtyByKey.entries()).map(([key, qty]) => {
+        const [addOnId, variantIdRaw] = key.split('::');
+        const variantId = variantIdRaw?.trim() || undefined;
+        return { addOnId, variantId, quantity: qty };
+      });
+    },
+    [isCustomerSelfServeChange, initialAddOnMinQtyByKey, initialAddOnMinTotalByAddOnId]
+  );
+
+  const updateAddOnSelections = useCallback(
+    (updater: AddOnSelectionsUpdater) => {
+      setAddOnSelections((prev) => {
+        const rawNext = typeof updater === 'function' ? updater(prev) : updater;
+        return applyChangeFlowAddOnFloor(rawNext);
+      });
+    },
+    [applyChangeFlowAddOnFloor, setAddOnSelections]
+  );
+
+  return {
+    initialAddOnMinQtyByKey,
+    initialAddOnMinTotalByAddOnId,
+    updateAddOnSelections,
+  };
+}