tf-checkout-react 1.7.31 → 2.0.0-beta.1

package/src/components/addonsContainer/utils/index.tsx

@@ -1,231 +0,0 @@
-import _isEmpty from 'lodash/isEmpty'
-import _isNull from 'lodash/isNull'
-import _reverse from 'lodash/reverse'
-import _sortBy from 'lodash/sortBy'
-
-interface ObjectLiteral {
-  [key: string]: any;
-}
-
-export const generateSelectOptions = (minCount = 1, maxCount = 10) => {
-  const options = []
-  for (let i = minCount; i <= maxCount; i++) {
-    options.push({ label: i, value: i })
-  }
-  return options
-}
-
-const generateStockBasedOnLimitations = (
-  addon: any,
-  ticketQuantity: number
-) => {
-  // Generate addon available stock count based on limitations
-  const { flagLimitToTicketQuantity, maxQuantity, limitPerTicket } = addon
-
-  let allowedStockCount
-
-  // Generate stock
-  if (flagLimitToTicketQuantity) {
-    // Limited to ticket quantity case
-    allowedStockCount = ticketQuantity
-  } else if (maxQuantity && limitPerTicket) {
-    const stockBasedOnLimitPerTicket = limitPerTicket * ticketQuantity
-    // Both maximum quantity and limited to per ticket selected case, stock is minimum of them
-    allowedStockCount =
-      maxQuantity <= stockBasedOnLimitPerTicket
-        ? maxQuantity
-        : stockBasedOnLimitPerTicket
-  } else if (maxQuantity && !limitPerTicket) {
-    // Limited to maximum quantity case
-    allowedStockCount = maxQuantity
-  } else if (!maxQuantity && limitPerTicket) {
-    // Limited to per ticket case
-    allowedStockCount = limitPerTicket * ticketQuantity
-  }
-
-  return Number(allowedStockCount)
-}
-
-const filterStockBasedOnAvailability = (
-  generatedStock: any,
-  availableStock: any
-) => {
-  //  Check generated stock count admissibility with addon stock availability
-  let filteredStockCount = generatedStock
-
-  if (generatedStock) {
-    if (generatedStock > availableStock && !_isNull(availableStock)) {
-      filteredStockCount = availableStock
-    }
-  } else {
-    // Not set any restriction
-    // Here 10 value is business logic
-    filteredStockCount = 10
-
-    if (!_isNull(availableStock) && availableStock < filteredStockCount) {
-      filteredStockCount = availableStock
-    }
-  }
-
-  return filteredStockCount
-}
-
-export const getAddonSelectOptions = (addons: any, choosedTicketCount: any) => {
-  const addonsWithOptions: ObjectLiteral = {}
-  const groupsWithSelectedVariantsInfo: ObjectLiteral = {}
-  const groupsWithVariants: ObjectLiteral = {}
-
-  addons.forEach((addon: any) => {
-    // Here addon can act either as simple Addon or Addon Group
-    const {
-      id,
-      stock: simpleAddonStock,
-      variants,
-      active,
-      flagLimitToTicketQuantity,
-      maxQuantity,
-      limitPerTicket,
-    } = addon
-
-    if (variants) {
-      // Addon Group with inside addon variants case
-      variants.forEach((variant: any) => {
-        const { id: variantId, stock: variantStock } = variant
-
-        // null checking is for unlimited stock value
-        if (active && (variantStock > 0 || _isNull(variantStock))) {
-          // Generate Addon Group allowed stock count based on limitations
-          const stockBasedOnLimitation = generateStockBasedOnLimitations(
-            addon,
-            choosedTicketCount
-          )
-
-          // Detect if group has limitation or not
-          if (flagLimitToTicketQuantity || maxQuantity || limitPerTicket) {
-            // Generate Group with inside variants info
-            if (groupsWithSelectedVariantsInfo[id]) {
-              // Set group limit
-              if (
-                groupsWithSelectedVariantsInfo[id].limit <
-                stockBasedOnLimitation
-              ) {
-                groupsWithSelectedVariantsInfo[
-                  id
-                ].limit = stockBasedOnLimitation
-              }
-
-              // Set choosed variants info
-              groupsWithSelectedVariantsInfo[id] = {
-                ...groupsWithSelectedVariantsInfo[id],
-                choosedVariants: {
-                  ...groupsWithSelectedVariantsInfo[id].choosedVariants,
-                  [variantId]: 0,
-                },
-              }
-            } else {
-              groupsWithSelectedVariantsInfo[id] = {
-                limit: stockBasedOnLimitation,
-                selectedCount: 0,
-                choosedVariants: { [variantId]: 0 },
-              }
-            }
-          }
-
-          // Check stock admissibility with addon stock availability
-          const allowedVariantStockCount = filterStockBasedOnAvailability(
-            stockBasedOnLimitation,
-            variantStock
-          )
-
-          // Generate options for variant
-          const variantOptions = generateSelectOptions(
-            0,
-            allowedVariantStockCount
-          )
-
-          addonsWithOptions[variantId] = [...variantOptions]
-
-          // Generate Group with its variants list
-          groupsWithVariants[id] = {
-            ...groupsWithVariants[id],
-            [variantId]: allowedVariantStockCount,
-          }
-        }
-      })
-    } else {
-      // Simple addon case, null checking is for unlimited stock value
-      if (active && (simpleAddonStock > 0 || _isNull(simpleAddonStock))) {
-        // Generate Addon Group allowed stock count based on limitations
-        const stockBasedOnLimitation = generateStockBasedOnLimitations(
-          addon,
-          choosedTicketCount
-        )
-
-        // Check stock admissibility with addon stock availability
-        const allowedVariantStockCount = filterStockBasedOnAvailability(
-          stockBasedOnLimitation,
-          simpleAddonStock
-        )
-
-        const addonOptions = generateSelectOptions(0, allowedVariantStockCount)
-        addonsWithOptions[id] = [...addonOptions]
-      }
-    }
-  })
-
-  return {
-    addonsWithOptions,
-    groupsWithSelectedVariantsInfo,
-    groupsWithVariants,
-  }
-}
-
-export const getTicketRelatedAddons = (addons: any, ticketId: any) => {
-  // Filter addons based on choosed ticket
-  const filteredAddons: any = addons.filter(
-    (addon: any) =>
-      _isNull(addon.prerequisiteTicketTypeIds) ||
-      addon.prerequisiteTicketTypeIds.includes(ticketId)
-  )
-
-  return filteredAddons
-}
-
-export const getSortedAddons = (addons: any, sortDirection = 'asc') => {
-  const addonsCopy = [...addons]
-
-  addonsCopy.forEach(addon => {
-    if (addon.variants) {
-      const unsortedVariants: any = []
-      addon.variants.forEach((variant: any) => {
-        unsortedVariants.push({
-          ...variant,
-          sortOrder: Number(variant.sortOrder),
-        })
-      })
-      addon.sortOrder = Number(addon.variants[0].sortOrder)
-      const sortedVariants = _sortBy(
-        unsortedVariants,
-        variant => variant.sortOrder
-      )
-      addon.variants = sortedVariants
-    } else {
-      addon.sortOrder = Number(addon.sortOrder)
-    }
-  })
-
-  const sortedAddons = _sortBy(addonsCopy, addon => addon.sortOrder)
-  if (sortDirection === 'desc') {
-    return _reverse(sortedAddons)
-  }
-
-  return sortedAddons
-}
-
-export const isAtLeastOneAddonSelected = (value: any) => {
-  const selectedAddons = Object.fromEntries(
-    Object.entries(value).filter(([_, count]) => Number(count) !== 0)
-  )
-
-  return !_isEmpty(selectedAddons)
-}

package/src/components/billing-info-container/hooks/index.ts

@@ -1,3 +0,0 @@
-export { usePaymentRedirect } from './usePaymentRedirect'
-export { useStripePayment } from './useStripePayment'
-export { usePaymentContext } from './usePaymentContext'

package/src/components/billing-info-container/hooks/usePaymentContext.ts

@@ -1,22 +0,0 @@
-import { useCallback } from 'react'
-
-export const usePaymentContext = () => {
-  const storePaymentContext = useCallback((context: any) => {
-    localStorage.setItem('stripe_payment_context', JSON.stringify(context))
-  }, [])
-
-  const getPaymentContext = useCallback(() => {
-    const storedContext = localStorage.getItem('stripe_payment_context')
-    return storedContext ? JSON.parse(storedContext) : null
-  }, [])
-
-  const clearPaymentContext = useCallback(() => {
-    localStorage.removeItem('stripe_payment_context')
-  }, [])
-
-  return {
-    storePaymentContext,
-    getPaymentContext,
-    clearPaymentContext
-  }
-}

package/src/components/billing-info-container/hooks/usePaymentRedirect.ts

@@ -1,145 +0,0 @@
-import { Stripe } from '@stripe/stripe-js'
-import { FormikHelpers } from 'formik'
-import _identity from 'lodash/identity'
-import { useEffect } from 'react'
-
-import { handlePaymentMiddleWare } from '../../paymentContainer/handlePayment'
-
-interface PaymentContext {
-  attributes: any
-  isFreeTickets: boolean
-  updatedOrderData: any
-  eventId: string
-  values: any
-  formikHelpers: FormikHelpers<any>
-  checkoutResponse: any
-  checkoutUpdateResponse: any
-  timestamp: number
-}
-
-interface UsePaymentRedirectProps {
-  stripeRef: React.MutableRefObject<Stripe | null>
-  setError: (error: string | null) => void
-  setLoading: (loading: boolean) => void
-  removeReferralKey: () => void
-  removeAdditionalConfigs: () => void
-  handleSubmit: (
-    values: any,
-    formikHelpers: FormikHelpers<any>,
-    eventId: any,
-    checkoutResponse: any,
-    checkoutUpdateResponse: any,
-    paymentResponse: any
-  ) => void
-  isBrowser: boolean
-}
-
-export const usePaymentRedirect = ({
-  stripeRef,
-  setError,
-  setLoading,
-  removeReferralKey,
-  removeAdditionalConfigs,
-  handleSubmit,
-  isBrowser,
-}: UsePaymentRedirectProps) => {
-  useEffect(() => {
-    const handlePaymentReturn = async () => {
-      const urlParams = new URLSearchParams(window.location.search)
-      const isPaymentReturn = urlParams.get('payment_return')
-      const clientSecret = urlParams.get('payment_intent_client_secret')
-
-      if (isPaymentReturn && clientSecret && stripeRef.current) {
-        setLoading(true)
-
-        try {
-          // Get stored payment context
-          const storedContext = localStorage.getItem('stripe_payment_context')
-          if (!storedContext) {
-            setError('Payment context not found')
-            setLoading(false)
-            return
-          }
-
-          const paymentContext: PaymentContext = JSON.parse(storedContext)
-          const { paymentIntent } = await stripeRef.current.retrievePaymentIntent(
-            clientSecret
-          )
-
-          if (paymentIntent?.status === 'succeeded') {
-
-            // Clean up stored context
-            localStorage.removeItem('stripe_payment_context')
-
-            // Continue with the success flow using stored context
-            let paymentResponse = null
-            await handlePaymentMiddleWare(
-              null,
-              {},
-              {
-                reviewData: paymentContext.attributes,
-                isFreeTickets: paymentContext.isFreeTickets,
-                paymentPlanIsAvailable: false,
-                showPaymentPlanSection: false,
-                handlePayment: (data: any) => {
-                  paymentResponse = data
-                },
-                setPaymentIsLoading: _identity,
-                setError: _identity,
-                orderData: paymentContext.updatedOrderData,
-                eventId: paymentContext.eventId,
-                isBrowser,
-                onPaymentError: (error: any) => {
-                  throw error
-                },
-              }
-            )
-
-            // Complete the flow with cleanup and handleSubmit
-            removeReferralKey()
-            removeAdditionalConfigs()
-            handleSubmit(
-              paymentContext.values,
-              paymentContext.formikHelpers,
-              paymentContext.eventId,
-              paymentContext.checkoutResponse,
-              paymentContext.checkoutUpdateResponse,
-              paymentResponse
-            )
-
-            // Clean URL parameters
-            window.history.replaceState({}, document.title, window.location.pathname)
-          } else if (paymentIntent?.status === 'requires_action') {
-            setError('Payment requires additional action')
-            // Clean up stored context and URL to prevent infinite loop
-            localStorage.removeItem('stripe_payment_context')
-            window.history.replaceState({}, document.title, window.location.pathname)
-          } else {
-            setError(`Payment failed or was cancelled.`)
-            // Clean up stored context and URL to prevent infinite loop
-            localStorage.removeItem('stripe_payment_context')
-            window.history.replaceState({}, document.title, window.location.pathname)
-          }
-        } catch (error) {
-          console.error('Error handling payment return:', error)
-          setError('Error processing payment return')
-          // Clean up stored context and URL to prevent infinite loop
-          localStorage.removeItem('stripe_payment_context')
-          window.history.replaceState({}, document.title, window.location.pathname)
-        } finally {
-          setLoading(false)
-        }
-      }
-    }
-
-    handlePaymentReturn()
-  }, [
-    stripeRef.current,
-    setError,
-    setLoading,
-    removeReferralKey,
-    removeAdditionalConfigs,
-    handleSubmit,
-    isBrowser,
-  ])
-}

package/src/components/billing-info-container/hooks/useStripePayment.ts

@@ -1,119 +0,0 @@
-import { FormikHelpers } from 'formik'
-import _identity from 'lodash/identity'
-
-import { handlePaymentMiddleWare } from '../../paymentContainer/handlePayment'
-
-interface PaymentData {
-  attributes: any
-  isFreeTickets: boolean
-  updatedOrderData: any
-  eventId: string
-}
-
-interface UseStripePaymentProps {
-  stripeRef: any
-  elementsRef: React.MutableRefObject<any>
-  setError: (error: string | null) => void
-  isBrowser: boolean
-}
-
-export const useStripePayment = ({
-  stripeRef,
-  elementsRef,
-  setError,
-  isBrowser,
-}: UseStripePaymentProps) => {
-  const processPayment = async (
-    paymentDataResponse: any,
-    values: any,
-    formikHelpers: FormikHelpers<any>,
-    checkoutResponse: any,
-    checkoutUpdateResponse: any,
-    paymentData: PaymentData
-  ) => {
-    const { attributes, isFreeTickets, updatedOrderData, eventId } = paymentData
-
-    if (!isFreeTickets) {
-      if (!stripeRef.current) {
-        setError('Stripe is not ready')
-        return null
-      }
-
-      // Step 1: Submit elements first
-      const { error: submitError } = await elementsRef.current.submit()
-      if (submitError) {
-        setError('' + submitError?.message)
-        return null
-      }
-
-      // Step 2: Store payment context before potential redirect
-      const paymentContext = {
-        attributes,
-        isFreeTickets,
-        updatedOrderData,
-        eventId,
-        values,
-        formikHelpers,
-        checkoutResponse,
-        checkoutUpdateResponse,
-        timestamp: Date.now(),
-      }
-      localStorage.setItem('stripe_payment_context', JSON.stringify(paymentContext))
-
-      // Step 3: Confirm payment with current page return URL
-      const confirmParams: any = {
-        return_url:
-          window.location.href +
-          (window.location.href.includes('?') ? '&' : '?') +
-          'payment_return=true',
-      }
-      if (values?.phone) {
-        const rawPhone = String(values.phone).replace(/[\s\-().]/g, '')
-        const e164Phone = rawPhone.startsWith('+') ? rawPhone : `+${rawPhone}`
-        confirmParams.payment_method_data = {
-          billing_details: { phone: e164Phone },
-        }
-      }
-      const { error: confirmError } = await stripeRef.current.confirmPayment({
-        clientSecret:
-          paymentDataResponse.data.attributes.payment_method.stripe_client_secret,
-        elements: elementsRef.current,
-        confirmParams,
-        redirect: 'if_required',
-      })
-
-      if (confirmError) {
-        setError('' + confirmError?.message)
-        return null
-      }
-    }
-
-    // Handle payment middleware for non-redirect payments
-    let paymentResponse = null
-    await handlePaymentMiddleWare(
-      null,
-      {},
-      {
-        reviewData: attributes,
-        isFreeTickets,
-        paymentPlanIsAvailable: false,
-        showPaymentPlanSection: false,
-        handlePayment: (data: any) => {
-          paymentResponse = data
-        },
-        setPaymentIsLoading: _identity,
-        setError: _identity,
-        orderData: updatedOrderData,
-        eventId,
-        isBrowser,
-        onPaymentError: (error: any) => {
-          throw error
-        },
-      }
-    )
-
-    return paymentResponse
-  }
-
-  return { processPayment }
-}