tf-checkout-react-native 1.0.47 → 2.0.0-beta.10

package/src/core/CheckoutCore/CheckoutCore.tsx

@@ -1,113 +0,0 @@
-/**
- * @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

@@ -1,23 +0,0 @@
-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

@@ -1,20 +0,0 @@
-# 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

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

package/src/core/LoginCore/LoginCore.tsx

@@ -1,140 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,148 +0,0 @@
-# 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

@@ -1,44 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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