tf-checkout-react-native 1.0.37 → 1.0.40

package/src/core/CheckoutCore/CheckoutCore.tsx

@@ -0,0 +1,113 @@
+/**
+ * @deprecated This component is deprecated and will be removed in a future release.
+ * Please use the hooks from 'tf-checkout-react-native' instead.
+ * Example: import { useCheckoutFlow } from 'tf-checkout-react-native'
+ * See README.md in this directory for migration guide.
+ */
+import React, { useCallback, useEffect, useState } from 'react'
+import { forwardRef, useImperativeHandle } from 'react'
+import BackgroundTimer from 'react-native-background-timer'
+
+import {
+  fetchEventConditions,
+  fetchOrderDetails,
+  fetchOrderReview,
+  postOnFreeRegistration,
+  postOnPaymentSuccess,
+} from '../../api/ApiClient'
+import {
+  IFetchAccessTokenResponse,
+  IFreeRegistrationResponse,
+  IMyOrderDetailsResponse,
+  IOrderReviewResponse,
+} from '../../api/types'
+import { refreshAccessToken as refreshAccessTokenAsync } from '../../helpers/RefreshAccessToken'
+import { CheckoutCoreHandle, ICheckoutCoreProps } from './CheckoutCoreTypes'
+
+/**
+ * @deprecated Use the hooks from 'tf-checkout-react-native' instead.
+ * Example: import { useCheckoutFlow } from 'tf-checkout-react-native'
+ */
+const CheckoutCore = forwardRef<CheckoutCoreHandle, ICheckoutCoreProps>((props, ref) => {
+  const [secondsLeft, setSecondsLeft] = useState(420)
+  const [timerOn, setTimerOn] = useState(false)
+
+  const handleStopTimer = useCallback(() => {
+    BackgroundTimer.stop()
+    BackgroundTimer.stopBackgroundTimer()
+  }, [])
+
+  const handleStartTimer = useCallback(() => {
+    BackgroundTimer.runBackgroundTimer(() => {
+      setSecondsLeft((secs) => {
+        if (secs > 0) {
+          return secs - 1
+        } else {
+          return 0
+        }
+      })
+    }, 1000)
+  }, [])
+
+  const handleTimeIsUp = () => {
+    BackgroundTimer.stopBackgroundTimer()
+    props.onCartExpired?.()
+  }
+
+  useEffect(() => {
+    if (secondsLeft === 0) {
+      handleTimeIsUp()
+    }
+    props.onSecondsLeftChange?.(secondsLeft)
+  }, [secondsLeft])
+
+  useEffect(() => {
+    if (timerOn) {
+      handleStartTimer()
+    } else {
+      BackgroundTimer.stopBackgroundTimer()
+    }
+    return () => {
+      BackgroundTimer.stopBackgroundTimer()
+    }
+  }, [handleStartTimer, timerOn])
+
+  useImperativeHandle(ref, () => ({
+    async getEventConditions(): Promise<any> {
+      return await fetchEventConditions()
+    },
+
+    async getPurchaseOrderDetails(orderId: string): Promise<IMyOrderDetailsResponse> {
+      return await fetchOrderDetails(orderId)
+    },
+
+    async getOrderReview(orderHash: string): Promise<IOrderReviewResponse> {
+      const res = await fetchOrderReview(orderHash)
+      if (res.orderReviewData) {
+        setSecondsLeft(res.orderReviewData.expiresAt)
+        setTimerOn(true)
+      }
+      return res
+    },
+
+    async freeRegistration(orderHash: string): Promise<IFreeRegistrationResponse> {
+      return await postOnFreeRegistration(orderHash)
+    },
+
+    async paymentSuccess(orderHash: string): Promise<any> {
+      return await postOnPaymentSuccess(orderHash)
+    },
+
+    async refreshAccessToken(refreshToken?: string): Promise<IFetchAccessTokenResponse> {
+      return await refreshAccessTokenAsync(refreshToken)
+    },
+
+    stopCartTimer() {
+      return handleStopTimer()
+    },
+  }))
+
+  return <>{props.children}</>
+})
+
+export default CheckoutCore

package/src/core/CheckoutCore/CheckoutCoreTypes.ts

@@ -0,0 +1,23 @@
+import {
+  IFreeRegistrationResponse,
+  IMyOrderDetailsResponse,
+  IOrderReviewResponse,
+} from '../../api/types'
+import { ICoreProps } from '../CoreProps'
+import { SessionCoreHandleType } from '../Session/SessionCoreTypes'
+
+export type CheckoutCoreHandleType = {
+  getEventConditions(): Promise<any>
+  getPurchaseOrderDetails(orderId: string): Promise<IMyOrderDetailsResponse>
+  getOrderReview(orderHash: string): Promise<IOrderReviewResponse>
+  freeRegistration(orderHash: string): Promise<IFreeRegistrationResponse>
+  paymentSuccess(orderHash: string): Promise<any>
+  stopCartTimer(): void
+}
+
+export interface ICheckoutCoreProps extends ICoreProps {
+  onCartExpired?: () => void
+  onSecondsLeftChange?: (secondsLeft: number) => void
+}
+
+export type CheckoutCoreHandle = CheckoutCoreHandleType & SessionCoreHandleType

package/src/core/CheckoutCore/README.md

@@ -0,0 +1,20 @@
+# CheckoutCore (Deprecated)
+
+> ⚠️ **DEPRECATED**: This component is deprecated and will be removed in a future release.
+
+## Migration Guide
+
+Please use the hooks directly from the package, which are all exported from the root.
+
+See the [Migration Guide](../MIGRATION.md) for detailed instructions on how to replace CheckoutCore functions with the new hooks-based implementation.
+
+## Function Replacements
+
+| CheckoutCore Function         | Replacement Hook                                                     |
+| ----------------------------- | -------------------------------------------------------------------- |
+| `getEventConditions()`        | `useEventConditions(eventId)` from `tf-checkout-react-native`        |
+| `getOrderReview(orderHash)`   | `usePaymentData()` from `tf-checkout-react-native`                   |
+| `freeRegistration(orderHash)` | `usePaymentSuccess()` with free ticket handling in `useCheckoutFlow` |
+| `paymentSuccess(orderHash)`   | `usePaymentSuccess()` from `tf-checkout-react-native`                |
+
+For a comprehensive checkout experience, use `useCheckoutFlow()` from `tf-checkout-react-native`.

package/src/core/CoreProps.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from 'react'
+
+export interface ICoreProps {
+  children: ReactNode | ReactNode[]
+}

package/src/core/LoginCore/LoginCore.tsx

@@ -0,0 +1,140 @@
+import React, { forwardRef, useImperativeHandle } from 'react'
+
+import {
+  authorize,
+  closeSession,
+  fetchAccessToken,
+  fetchUserProfile,
+  requestResetPassword,
+  requestRestorePassword,
+} from '../../api/ApiClient'
+import { ICloseSessionResponse, IResetPasswordRequestData } from '../../api/types'
+import { ILoginFields } from '../../components/login/types'
+import { IStoredUserData, LocalStorageKeys, storeData } from '../../helpers/LocalStorage'
+import { IUserProfilePublic } from '../../types'
+import { ICoreProps } from '../CoreProps'
+import { getFetchAccessTokenBody } from './LoginCoreHelper'
+import { ILoginCoreResponse, LoginCoreHandle } from './LoginCoreTypes'
+
+const LoginCore = forwardRef<LoginCoreHandle, ICoreProps>((props, ref) => {
+  useImperativeHandle(ref, () => ({
+    // #region Login
+    async login({ email, password }: ILoginFields): Promise<ILoginCoreResponse> {
+      const bodyFormData = new FormData()
+      bodyFormData.append('email', email)
+      bodyFormData.append('password', password)
+
+      const { code: authorizationCode, error: authorizationError } =
+        await authorize(bodyFormData)
+
+      if (authorizationError) {
+        return {
+          error: {
+            ...authorizationError,
+            extraData: { endpoint: 'authorize' },
+          },
+        }
+      }
+
+      if (!authorizationCode) {
+        return {
+          error: {
+            message: 'There is no authorization code',
+            extraData: { endpoint: 'authorize' },
+          },
+        }
+      }
+
+      const { accessTokenError, accessTokenData } = await fetchAccessToken(
+        getFetchAccessTokenBody(authorizationCode)
+      )
+
+      if (accessTokenError) {
+        return {
+          error: {
+            ...accessTokenError,
+            extraData: {
+              endpoint: 'accessToken',
+            },
+          },
+        }
+      }
+
+      const { userProfileError, userProfileData } = await fetchUserProfile()
+
+      if (userProfileError) {
+        return {
+          error: {
+            ...userProfileError,
+            extraData: {
+              endpoint: 'userProfile',
+            },
+          },
+        }
+      }
+
+      if (!userProfileData) {
+        return {
+          error: {
+            message: 'There is no user profile',
+            extraData: {
+              endpoint: 'userProfile',
+            },
+          },
+        }
+      }
+
+      const storedUserData: IStoredUserData = {
+        id: userProfileData!.id,
+        firstName: userProfileData!.firstName,
+        lastName: userProfileData!.lastName,
+        email: userProfileData!.email,
+      }
+
+      const userPublicData: IUserProfilePublic = {
+        customerId: userProfileData.id,
+        firstName: userProfileData.firstName,
+        lastName: userProfileData.lastName,
+        email: userProfileData.email,
+        phone: userProfileData.phone,
+        streetAddress: userProfileData.streetAddress,
+        zipCode: userProfileData.zipCode,
+        countryId: userProfileData.countryId,
+        city: userProfileData.city,
+        state: userProfileData.state,
+        company: userProfileData.company,
+        stateId: userProfileData.stateId,
+        dateOfBirth: userProfileData.dateOfBirth,
+      }
+
+      await storeData(LocalStorageKeys.USER_DATA, JSON.stringify(storedUserData))
+
+      return { userProfile: userPublicData, accessTokenData: accessTokenData }
+    },
+    // #endregion Login
+
+    // #region Logout
+    async logout(): Promise<ICloseSessionResponse> {
+      return await closeSession()
+    },
+    // #endregion Logout
+
+    // #region Restore Password
+    async restorePassword(email: string) {
+      const response = await requestRestorePassword(email)
+      return response
+    },
+    // #endregion Restore Password
+
+    // #region Reset Password
+    async resetPassword(data: IResetPasswordRequestData) {
+      const response = await requestResetPassword(data)
+      return response
+    },
+    // #endregion Reset Password
+  }))
+
+  return <>{props.children}</>
+})
+
+export default LoginCore

package/src/core/LoginCore/LoginCoreHelper.ts

@@ -0,0 +1,22 @@
+import { Config } from '../../helpers/Config'
+
+export const getFetchAccessTokenBody = (authorizationCode: string): FormData => {
+  const bodyFormDataToken = new FormData()
+  bodyFormDataToken.append('code', authorizationCode)
+  bodyFormDataToken.append('scope', 'profile')
+  bodyFormDataToken.append('grant_type', 'authorization_code')
+  bodyFormDataToken.append('client_id', Config.CLIENT_ID)
+  bodyFormDataToken.append('client_secret', Config.CLIENT_SECRET)
+
+  return bodyFormDataToken
+}
+
+export const getRefreshAccessTokenBody = (refreshToken: string): FormData => {
+  const bodyFormDataToken = new FormData()
+  bodyFormDataToken.append('grant_type', 'refresh_token')
+  bodyFormDataToken.append('client_id', Config.CLIENT_ID)
+  bodyFormDataToken.append('client_secret', Config.CLIENT_SECRET)
+  bodyFormDataToken.append('refresh_token', refreshToken)
+
+  return bodyFormDataToken
+}

package/src/core/LoginCore/LoginCoreTypes.ts

@@ -0,0 +1,21 @@
+import {
+  ICloseSessionResponse,
+  IFetchAccessTokenData,
+  IResetPasswordRequestData,
+  IRestorePasswordResponse,
+} from '../../api/types'
+import { ILoginFields } from '../../components/login/types'
+import { IError, IUserProfilePublic } from '../../types'
+
+export interface ILoginCoreResponse {
+  error?: IError
+  userProfile?: IUserProfilePublic
+  accessTokenData?: IFetchAccessTokenData
+}
+
+export type LoginCoreHandle = {
+  login(fields?: ILoginFields): Promise<ILoginCoreResponse>
+  logout(): Promise<ICloseSessionResponse>
+  restorePassword(email: string): Promise<IRestorePasswordResponse>
+  resetPassword(data: IResetPasswordRequestData): Promise<any>
+}

package/src/core/MIGRATION.md

@@ -0,0 +1,148 @@
+# Migration from Core Components to Hooks
+
+This document provides a guide for migrating from the deprecated `BillingCore` and `CheckoutCore` components to the new hooks-based implementation.
+
+## Overview
+
+The legacy Core components (`BillingCore` and `CheckoutCore`) are being deprecated in favor of modern React hooks that provide better composability, TypeScript support, and integration with React Query for improved data fetching and caching.
+
+All hooks are exported directly from the package root, so you can import them like this:
+
+```tsx
+import { useCart, useCheckout, useCheckoutFlow } from 'tf-checkout-react-native'
+```
+
+## Core Components to Hooks Mapping
+
+### BillingCore Functions
+
+| BillingCore Function               | Replacement Hook                             | Import Statement                                             |
+| ---------------------------------- | -------------------------------------------- | ------------------------------------------------------------ |
+| `getCart()`                        | `useCart()`                                  | `import { useCart } from 'tf-checkout-react-native'`         |
+| `getCountries()`                   | `useCountries()`                             | `import { useCountries } from 'tf-checkout-react-native'`    |
+| `getStates(countryId)`             | `useStates(countryId)`                       | `import { useStates } from 'tf-checkout-react-native'`       |
+| `getUserProfile()`                 | `useUserProfile()`                           | `import { useUserProfile } from 'tf-checkout-react-native'`  |
+| `registerNewUser(data)`            | `useRegisterUser()`                          | `import { useRegisterUser } from 'tf-checkout-react-native'` |
+| `checkoutOrder(body)`              | `useCheckout()`                              | `import { useCheckout } from 'tf-checkout-react-native'`     |
+| `refreshAccessToken(refreshToken)` | Use token management from `AuthProvider`     | Provided by authentication context                           |
+| `stopCartTimer()`                  | Cart timer is managed by `useCheckoutFlow()` | `import { useCheckoutFlow } from 'tf-checkout-react-native'` |
+
+### CheckoutCore Functions
+
+| CheckoutCore Function              | Replacement Hook                                | Import Statement                                                |
+| ---------------------------------- | ----------------------------------------------- | --------------------------------------------------------------- |
+| `getEventConditions()`             | `useEventConditions(eventId)`                   | `import { useEventConditions } from 'tf-checkout-react-native'` |
+| `getPurchaseOrderDetails(orderId)` | _Not yet implemented as hook_                   | -                                                               |
+| `getOrderReview(orderHash)`        | `usePaymentData()`                              | `import { usePaymentData } from 'tf-checkout-react-native'`     |
+| `freeRegistration(orderHash)`      | `usePaymentSuccess()` with free ticket handling | `import { usePaymentSuccess } from 'tf-checkout-react-native'`  |
+| `paymentSuccess(orderHash)`        | `usePaymentSuccess()`                           | `import { usePaymentSuccess } from 'tf-checkout-react-native'`  |
+| `refreshAccessToken(refreshToken)` | Use token management from `AuthProvider`        | Provided by authentication context                              |
+| `stopCartTimer()`                  | Cart timer is managed by `useCheckoutFlow()`    | `import { useCheckoutFlow } from 'tf-checkout-react-native'`    |
+
+## Timer Management
+
+The cart expiration timer is now handled automatically by the `useCheckoutFlow()` hook, which provides:
+
+- Automatic timer setup when cart data is fetched
+- Countdown management with `secondsLeft` state
+- Timer cleanup on component unmount
+- Callback for cart expiration via `onCartExpired` prop
+
+## Comprehensive Checkout Flow
+
+For a complete checkout experience, use the `useCheckoutFlow()` hook from `src/features/checkout-v2/hooks/use-checkout.ts`. This hook:
+
+1. Combines all necessary data fetching
+2. Manages form state with appropriate validation
+3. Handles the complete checkout and payment flow
+4. Provides callbacks for various checkout events
+5. Supports both single-page and multi-step checkout experiences
+
+## Migration Example
+
+### Before (using BillingCore):
+
+```tsx
+import { BillingCore, BillingCoreHandle } from 'tf-checkout-react-native'
+
+const billingRef = useRef<BillingCoreHandle>(null)
+
+useEffect(() => {
+  const fetchCart = async () => {
+    const cart = await billingRef.current?.getCart()
+    // handle cart data
+  }
+  fetchCart()
+}, [])
+
+// Later in the component
+<BillingCore ref={billingRef} onCartExpired={handleCartExpired}>
+  {/* children */}
+</BillingCore>
+```
+
+### After (using hooks):
+
+```tsx
+import { useCart, useCheckoutFlow } from 'tf-checkout-react-native'
+
+const { data: cart, isLoading } = useCart()
+const { secondsLeft } = useCheckoutFlow({
+  onCartExpired: handleCartExpired,
+  // other options
+})
+
+// Cart data is available in cart.data.attributes
+// secondsLeft provides the remaining cart time
+```
+
+## Additional Features in the New Implementation
+
+1. **React Query Integration**: Automatic caching, refetching, and loading states
+2. **TypeScript Support**: Full type definitions for all responses and parameters
+3. **Composable API**: Use only the hooks you need, when you need them
+4. **Form Integration**: Built-in form management with the checkout flow
+5. **Payment Processing**: Integrated Stripe payment handling
+
+## Full Example Using the Checkout Flow
+
+```tsx
+import { useCheckoutFlow } from 'tf-checkout-react-native'
+
+const CheckoutScreen = () => {
+  const {
+    onSubmit,
+    initialValues,
+    countries,
+    states,
+    orderItems,
+    secondsLeft,
+    isSubmitting,
+    isInitialLoading,
+  } = useCheckoutFlow({
+    onCartExpired: () => navigation.navigate('ExpiredScreen'),
+    onCheckoutSuccess: ({ hash, total, values }) => {
+      // Handle checkout success
+    },
+    onPaymentSuccess: (result) => {
+      // Handle payment success
+    },
+  })
+
+  if (isInitialLoading) {
+    return <LoadingIndicator />
+  }
+
+  return (
+    <CheckoutForm
+      onSubmit={onSubmit}
+      initialValues={initialValues}
+      countries={countries}
+      states={states}
+      orderItems={orderItems}
+      secondsLeft={secondsLeft}
+      isSubmitting={isSubmitting}
+    />
+  )
+}
+```

package/src/core/MyOrdersCore/MyOrdersCore.tsx

@@ -0,0 +1,44 @@
+import React from 'react'
+import { forwardRef, useImperativeHandle } from 'react'
+
+import {
+  fetchAccountTickets,
+  fetchMyOrders,
+  fetchOrderDetails,
+} from '../../api/ApiClient'
+import {
+  IFetchAccessTokenResponse,
+  IMyOrderDetailsResponse,
+  IMyOrdersRequestParams,
+  IMyOrdersResponse,
+} from '../../api/types'
+import { refreshAccessToken as refreshAccessTokenAsync } from '../../helpers/RefreshAccessToken'
+import { IAccountTicketsResponse } from '../../types'
+import { ICoreProps } from '../CoreProps'
+import { MyOrdersCoreHandle } from './MyOrdersCoreTypes'
+
+const MyOrdersCore = forwardRef<MyOrdersCoreHandle, ICoreProps>((props, ref) => {
+  useImperativeHandle(ref, () => ({
+    async getMyOrders(params: IMyOrdersRequestParams): Promise<IMyOrdersResponse> {
+      return await fetchMyOrders(params)
+    },
+
+    async getOrderDetails(orderId: string): Promise<IMyOrderDetailsResponse> {
+      return await fetchOrderDetails(orderId)
+    },
+
+    async refreshAccessToken(refreshToken?: string): Promise<IFetchAccessTokenResponse> {
+      return await refreshAccessTokenAsync(refreshToken)
+    },
+
+    async getAccountTickets(
+      params: IMyOrdersRequestParams
+    ): Promise<IAccountTicketsResponse> {
+      return await fetchAccountTickets(params)
+    },
+  }))
+
+  return <>{props.children}</>
+})
+
+export default MyOrdersCore

package/src/core/MyOrdersCore/MyOrdersCoreTypes.ts

@@ -0,0 +1,15 @@
+import {
+  IMyOrderDetailsResponse,
+  IMyOrdersRequestParams,
+  IMyOrdersResponse,
+} from '../../api/types'
+import { IAccountTicketsResponse } from '../../types'
+import { SessionCoreHandleType } from '../Session/SessionCoreTypes'
+
+export type MyOrdersCoreHandleType = {
+  getMyOrders(params: IMyOrdersRequestParams): Promise<IMyOrdersResponse>
+  getOrderDetails(orderId: string): Promise<IMyOrderDetailsResponse>
+  getAccountTickets(params: IMyOrdersRequestParams): Promise<IAccountTicketsResponse>
+}
+
+export type MyOrdersCoreHandle = MyOrdersCoreHandleType & SessionCoreHandleType

package/src/core/OrderDetailsCore/OrderDetailsCore.tsx

@@ -0,0 +1,36 @@
+import React, { forwardRef, useImperativeHandle } from 'react'
+
+import { removeTicketFromResale, resaleTicket } from '../../api/ApiClient'
+import {
+  IFetchAccessTokenResponse,
+  IRemoveTicketFromResaleResponse,
+  IResaleTicketResponse,
+} from '../../api/types'
+import { refreshAccessToken as refreshAccessTokenAsync } from '../../helpers/RefreshAccessToken'
+import { ICoreProps } from '../CoreProps'
+import { OrderDetailsCoreHandle } from './OrderDetailsCoreTypes'
+
+const OrderDetailsCore = forwardRef<OrderDetailsCoreHandle, ICoreProps>((props, ref) => {
+  useImperativeHandle(ref, () => ({
+    async resaleTicket(
+      data: FormData,
+      orderHash: string
+    ): Promise<IResaleTicketResponse> {
+      return await resaleTicket(data, orderHash)
+    },
+
+    async removeTicketFromResale(
+      orderHash: string
+    ): Promise<IRemoveTicketFromResaleResponse> {
+      return await removeTicketFromResale(orderHash)
+    },
+
+    async refreshAccessToken(refreshToken?: string): Promise<IFetchAccessTokenResponse> {
+      return await refreshAccessTokenAsync(refreshToken)
+    },
+  }))
+
+  return <>{props.children}</>
+})
+
+export default OrderDetailsCore

package/src/core/OrderDetailsCore/OrderDetailsCoreTypes.ts

@@ -0,0 +1,10 @@
+import { IRemoveTicketFromResaleResponse, IResaleTicketResponse } from '../../api/types'
+import { SessionCoreHandleType } from '../Session/SessionCoreTypes'
+
+type OrderDetailsCoreHandleType = {
+  resaleTicket(data: FormData, orderHash: string): Promise<IResaleTicketResponse>
+
+  removeTicketFromResale(orderHash: string): Promise<IRemoveTicketFromResaleResponse>
+}
+
+export type OrderDetailsCoreHandle = OrderDetailsCoreHandleType & SessionCoreHandleType

package/src/core/PurchaseConfirmationCore/PurchaseConfirmationCore.tsx

@@ -0,0 +1,37 @@
+import React, { forwardRef, useCallback, useImperativeHandle } from 'react'
+import BackgroundTimer from 'react-native-background-timer'
+
+import { fetchPurchaseConfirmation } from '../../api/ApiClient'
+import { IFetchAccessTokenResponse } from '../../api/types'
+import { refreshAccessToken as refreshAccessTokenAsync } from '../../helpers/RefreshAccessToken'
+import { ICoreProps } from '../CoreProps'
+import { PurchaseConfirmationCoreHandle } from './PurchaseConfirmationCoreTypes'
+
+const PurchaseConfirmationCore = forwardRef<PurchaseConfirmationCoreHandle, ICoreProps>(
+  (props, ref) => {
+    const handleStopTimer = useCallback(() => {
+      BackgroundTimer.stop()
+      BackgroundTimer.stopBackgroundTimer()
+    }, [])
+
+    useImperativeHandle(ref, () => ({
+      async getPurchaseConfirmation(orderHash: string): Promise<any> {
+        return await fetchPurchaseConfirmation(orderHash)
+      },
+
+      async refreshAccessToken(
+        refreshToken?: string
+      ): Promise<IFetchAccessTokenResponse> {
+        return await refreshAccessTokenAsync(refreshToken)
+      },
+
+      stopCartTimer() {
+        return handleStopTimer()
+      },
+    }))
+
+    return <>{props.children}</>
+  }
+)
+
+export default PurchaseConfirmationCore

package/src/core/PurchaseConfirmationCore/PurchaseConfirmationCoreTypes.ts

@@ -0,0 +1,10 @@
+import { IPurchaseConfirmationResponse } from '../../api/types'
+import { SessionCoreHandleType } from '../Session/SessionCoreTypes'
+
+export type PurchaseConfirmationCoreHandleType = {
+  getPurchaseConfirmation(orderHash: string): Promise<IPurchaseConfirmationResponse>
+  stopCartTimer(): void
+}
+
+export type PurchaseConfirmationCoreHandle = PurchaseConfirmationCoreHandleType &
+  SessionCoreHandleType

package/src/core/ResetPasswordCore/ResetPasswordCore.tsx

@@ -0,0 +1,21 @@
+import React, { forwardRef, useImperativeHandle } from 'react'
+
+import { requestResetPassword } from '../../api/ApiClient'
+import { IResetPasswordRequestData, IResetPasswordResponse } from '../../api/types'
+import { ICoreProps } from '../CoreProps'
+import { ResetPasswordCoreHandle } from './ResetPasswordCoreTypes'
+
+const ResetPasswordCore = forwardRef<ResetPasswordCoreHandle, ICoreProps>(
+  (props, ref) => {
+    useImperativeHandle(ref, () => ({
+      async postResetPassword(
+        data: IResetPasswordRequestData
+      ): Promise<IResetPasswordResponse> {
+        return await requestResetPassword(data)
+      },
+    }))
+    return <>{props.children}</>
+  }
+)
+
+export default ResetPasswordCore