@seeka-labs/cli-apps 3.7.0 → 3.8.2

package/dist/ai-context/internal/examples/v2/typeform/app/ui/src/components/setup/steps/form-binding/index.tsx

@@ -0,0 +1,215 @@
+
+import { useTokens } from "@/seeka-labs-app-sdk-ui/shared/auth/useTokens"
+import { FormProvider } from "@/seeka-labs-app-sdk-ui/shared/form/provider"
+import { SeekaAppWizardHeading } from "@/seeka-labs-app-sdk-ui/wizard/heading"
+import { SeekaAppWizardStep } from "@/seeka-labs-app-sdk-ui/wizard/step"
+import { SeekaAppWizardStepActions } from "@/seeka-labs-app-sdk-ui/wizard/step/actions"
+import { SeekaAppWizardStepContent } from "@/seeka-labs-app-sdk-ui/wizard/step/content"
+import { yupResolver } from '@hookform/resolvers/yup'
+import AddCircleOutlineIcon from '@mui/icons-material/AddCircleOutline'
+import { Button, Stack } from "@mui/material"
+import { TypeformFormBinding } from "@seeka-app-typeform/lib"
+import { appApi, getActivityNameTitle } from "@seeka-labs-internal/lib-react-common"
+import { getActivityName, TrackingActivityNames } from "@seeka-labs/converge"
+import { appAccessTokenHeaderName, coreApiAccessTokenHeaderName } from "@seeka-labs/sdk-apps-core"
+import { enqueueSnackbar } from "notistack"
+import { useMemo, useState } from "react"
+import { useFieldArray, useForm } from "react-hook-form"
+import { v4 as uuidv4 } from 'uuid'
+import * as yup from 'yup'
+import typeformAdsIcon from '../../../../assets/typeform-icon.png'
+import { FormBindingRow } from "./row"
+
+type Props = {
+    onNext?: () => void
+    onBack?: () => void
+}
+
+export const TypeformConversionMappingFormSchema = yup
+    .object<{ bindings: TypeformFormBinding[] }>()
+    .shape({
+        bindings: yup
+            .array()
+            .of(
+                yup
+                    .object<TypeformFormBinding>()
+                    .shape({
+                        // top‐level props
+                        id: yup
+                            .string()
+                            .uuid('Must be a valid UUID')
+                            .nonNullable()
+                            .required('Required'),
+                        typeFormFormId: yup
+                            .string()
+                            .nonNullable()
+                            .required('Required'),
+                        formSubmitEventName: yup
+                            .string()
+                            .nonNullable()
+                            .required('Required')
+                    })
+            )
+            .min(1, 'At least one mapping is required')
+            .required('At least one mapping is required'),
+    })
+    .required()
+
+export type TypeformConversionMappingFormType = yup.InferType<
+    typeof TypeformConversionMappingFormSchema
+>;
+
+export const TypeformFormBindingStep = ({ onNext, onBack }: Props) => {
+    const [saving, setSaving] = useState(false);
+    // const [loading, setLoading] = useState(true);
+    const appTokens = useTokens();
+    const activityNamesQuery = appApi.endpoints.referenceDataGetAllActivityNames.useQuery({ organisationBrandId: window.seekaAppConfig.organisationBrandId })
+
+    const formBindings = (window.seekaAppConfig.state.formBindings || []).map((m) => {
+        return {
+            ...m,
+            id: m.id || uuidv4()
+        }
+    });
+    const methods = useForm<TypeformConversionMappingFormType>({
+        resolver: yupResolver(TypeformConversionMappingFormSchema),
+        mode: "all",
+        reValidateMode: "onChange",
+        defaultValues: {
+            bindings: formBindings
+        }
+    });
+    const { control, handleSubmit, watch, trigger, formState: { errors, isDirty } } = methods
+    const bindings = useFieldArray({
+        name: "bindings",
+        control: control,
+    });
+
+    const isValid = Object.keys(errors || {}).length === 0 && bindings.fields.length > 0
+
+    const activityNameOptions = useMemo(() => {
+        return (activityNamesQuery?.data?.result || []).filter(Boolean).map(e => ({
+            activityName: getActivityName(e),
+            activityNameCustom: getActivityName(e) === TrackingActivityNames.Custom ? e : undefined,
+            label: getActivityNameTitle(e),
+            key: e
+        }));
+    }, [activityNamesQuery?.data?.result])
+
+    const onAdd = () => {
+        bindings.append({
+            id: uuidv4(),
+            typeFormFormId: '',
+            formSubmitEventName: 'Lead'
+        })
+        trigger()
+    }
+
+    const onDelete = (mappingIndex: number) => {
+        bindings.remove(mappingIndex)
+    }
+
+    const onSubmit = async (data: TypeformConversionMappingFormType) => {
+        setSaving(true)
+        let success = false;
+        try {
+            const response = await fetch(window.seekaAppConfig.appBaseUrl + '/app/api/settings/form-bindings', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    [appAccessTokenHeaderName]: 'Bearer ' + appTokens?.appAccessToken,
+                    [coreApiAccessTokenHeaderName]: 'Bearer ' + appTokens?.coreApiAccessToken,
+                },
+                body: JSON.stringify({ bindings: data.bindings })
+            })
+            if (response.ok) {
+                success = true;
+                window.seekaAppConfig.state.formBindings = data.bindings as any
+            }
+        }
+        catch (error) {
+            console.error(error);
+        }
+        finally {
+            setSaving(false)
+        }
+        if (success) {
+            enqueueSnackbar('Saved', { variant: 'success' });
+            if (onNext) {
+                onNext()
+            }
+        }
+        else {
+            enqueueSnackbar('Failed', { variant: 'error' });
+        }
+    };
+
+    const isLoading = activityNamesQuery?.isLoading || activityNameOptions.length === 0;
+
+    return (
+        <SeekaAppWizardStep loading={isLoading}>
+            <FormProvider methods={methods}>
+                <SeekaAppWizardHeading title="Configure form bindings" image={typeformAdsIcon}>
+                    In this step you will create bindings for Typeform submissions to Seeka events.
+                </SeekaAppWizardHeading>
+                {/* <SeekaAppWizardStepContent title="Conversion mapping and activation" subtitle="In the below step you will be able to match Seeka events to existing conversion actions in Typeform.">
+                    <ol>
+                        <li>Ensure you have created the conversions you wish to map in Typeform.</li>
+                        <li>In the left dropdown select the Seeka event you want to match to a conversion action.</li>
+                        <li>In the right dropdown select the relevant Typeform conversion action you wish to match to the Seeka event.</li>
+                        <li>To active the sending of data to this pairing, toggle the event to active.</li>
+                    </ol>
+                </SeekaAppWizardStepContent> */}
+                {/* Found in the URL of the form in Typeform */}
+
+                <SeekaAppWizardStepContent>
+                    {<Stack alignItems={'center'} justifyContent={'space-between'} sx={{ width: '100%', mt: 3 }} gap={2} direction={'column'}>
+                        {bindings && bindings.fields && bindings.fields.map((m, i) => (
+                            <FormBindingRow key={i} sourceActivityNames={activityNameOptions} onDelete={() => onDelete(i)} bindingIndex={i} />
+                        ))}
+
+                        <Button
+                            startIcon={<AddCircleOutlineIcon />}
+                            size="small"
+                            variant="text"
+                            onClick={onAdd}
+                        >
+                            Add binding
+                        </Button>
+                    </Stack>}
+                </SeekaAppWizardStepContent>
+                {/* <div style={{ marginBottom: '20px' }}>
+                    <pre>
+                        <code>{JSON.stringify(watch(), null, 1)}</code>
+                    </pre>
+                </div>
+                <div>
+                    <pre>
+                        <code>{JSON.stringify(errors, null, 1)}</code>
+                    </pre>
+                </div>
+                <div>
+                    <pre>
+                        <code>{JSON.stringify({
+                            isDirty,
+                            isValid,
+                            saving,
+                            // loading
+                        }, null, 1)}</code>
+                    </pre>
+                </div> */}
+
+                <SeekaAppWizardStepActions>
+                    <Stack direction="row" spacing={2}>
+                        {onBack && <Button variant='text' color="primary" onClick={onBack}>Back</Button>}
+                        {/* {onSkip && <Button variant='text' color="primary" onClick={onSkip}>Skip</Button>} */}
+                    </Stack>
+
+                    <Button variant='contained' loading={saving} type="submit" onClick={handleSubmit(onSubmit)} color="primary"
+                        disabled={(!isDirty && isValid) || (!isValid || saving)}
+                    >Next</Button>
+                </SeekaAppWizardStepActions>
+            </FormProvider>
+        </SeekaAppWizardStep>
+    )
+}

package/dist/ai-context/internal/examples/v2/typeform/app/ui/src/components/setup/steps/form-binding/row/index.tsx

@@ -0,0 +1,104 @@
+
+import { ActivityNameSelect } from "@/seeka-labs-app-sdk-ui/shared/form/fields/activityNameSelect";
+import { ActivityNameItem } from "@/seeka-labs-app-sdk-ui/shared/form/utils";
+import DeleteIcon from '@mui/icons-material/Delete';
+import RouteIcon from '@mui/icons-material/Route';
+
+import {
+    Box,
+    IconButton,
+    Stack,
+    Typography
+} from "@mui/material";
+import { RHFTextField } from "@seeka-labs-internal/lib-react-common";
+import { useFormContext } from "react-hook-form";
+import { TypeformConversionMappingFormType } from "..";
+
+type Props = {
+    onDelete: () => void
+    bindingIndex: number
+    sourceActivityNames: ActivityNameItem[]
+}
+
+export const FormBindingRow = ({ bindingIndex, onDelete, sourceActivityNames }: Props) => {
+    const htmlElementFormIdentifier = `bindings.${bindingIndex}` as 'bindings.0'
+    const methods = useFormContext<TypeformConversionMappingFormType>();
+    // const { control } = methods;
+
+    return (
+        <Box sx={{ border: "1px solid #ccc", borderRadius: "8px", padding: "12px", width: "100%" }}>
+            <Stack gap={1} direction={"column"} sx={{ width: "100%" }} justifyContent={'space-between'} alignItems={'flex-start'}>
+                <Stack gap={2} direction={"row"} justifyContent={'space-between'} alignItems={'center'} sx={{ width: '100%' }}>
+                    <Stack direction="row" gap={1}>
+                        <RouteIcon />
+                        <Typography variant="h5">Form binding {bindingIndex + 1}</Typography>
+                    </Stack>
+                    <Stack gap={2} direction={"row"} justifyContent={'flex-end'} alignItems={'center'}>
+                        <IconButton onClick={onDelete}
+                        >
+                            <DeleteIcon />
+                        </IconButton>
+                    </Stack>
+                </Stack>
+
+
+                <Stack gap={4} direction={"row"} sx={{ width: "100%" }} justifyContent={'flex-start'} alignItems={'center'}>
+                    <Stack gap={2} direction={"row"} justifyContent={'flex-start'} alignItems={'center'}>
+                        <Typography
+                            variant="body1"
+                            style={{
+                                display: 'inline-block',
+                                marginLeft: '10px',
+                                marginTop: '4px',
+                                whiteSpace: 'nowrap',
+                            }}
+                        >
+                            When Typeform ID
+                        </Typography>
+                        <RHFTextField
+                            fullWidth
+                            placeholder="Eg. V10ytQAA"
+                            size="small"
+                            variant="standard"
+                            sx={{ maxWidth: '200px' }}
+                            name={`${htmlElementFormIdentifier}.typeFormFormId` as 'bindings.0.typeFormFormId'}
+                        />
+
+                        <Typography
+                            variant="body1"
+                            style={{
+                                display: 'inline-block',
+                                marginLeft: '10px',
+                                marginTop: '4px',
+                                whiteSpace: 'nowrap',
+                            }}
+                        >
+                            is submitted
+                        </Typography>
+                    </Stack>
+
+                    <Stack gap={2} direction={"row"} justifyContent={'flex-start'} alignItems={'center'}>
+                        <Typography
+                            variant="body1"
+                            style={{
+                                display: 'inline-block',
+                                marginLeft: '10px',
+                                marginTop: '4px',
+                                whiteSpace: 'nowrap',
+                            }}
+                        >
+                            Then track event
+                        </Typography>
+
+                        <ActivityNameSelect
+                            activityNames={sourceActivityNames}
+                            name={`${htmlElementFormIdentifier}.formSubmitEventName` as 'bindings.0.formSubmitEventName'}
+                            stringValues
+                            allowCustomActivity
+                        />
+                    </Stack>
+                </Stack>
+            </Stack>
+        </Box>
+    );
+}

package/dist/ai-context/internal/examples/v2/typeform/app/ui/src/components/setup/steps/index.tsx

@@ -0,0 +1,31 @@
+import { Box } from "@mui/material";
+import { useEffect, useState } from "react";
+import { TypeformAuthStep } from "./auth";
+import { TypeformCompletedStep } from "./complete";
+import { TypeformFormBindingStep } from "./form-binding";
+
+export const SetupSteps = () => {
+    const appConfig = window.seekaAppConfig?.state;
+    const [activeStep, setActiveStep] = useState<number | null>(null)
+    // const [loading, setLoading] = useState(true)
+    // const appTokens = useTokens();
+
+    useEffect(() => {
+        if (appConfig.hasUserAccessToken) {
+            setActiveStep(1)
+        }
+        else {
+            setActiveStep(0)
+        }
+    }, [])
+
+    // if (activeStep === null || loading) return <Box><SeekaAppLoadingSpinner /></Box>
+
+    return (
+        <Box>
+            {activeStep === 0 && <TypeformAuthStep onSkip={() => setActiveStep(1)} />}
+            {activeStep === 1 && <TypeformFormBindingStep onNext={() => setActiveStep(2)} onBack={() => setActiveStep(0)} />}
+            {activeStep === 2 && <TypeformCompletedStep onBack={() => setActiveStep(1)} />}
+        </Box>
+    )
+}

package/dist/ai-context/internal/examples/v2/typeform/app/ui/src/components/typeform/login/index.tsx

@@ -0,0 +1,140 @@
+
+import { useTokens } from '@/seeka-labs-app-sdk-ui/shared/auth/useTokens';
+import { SeekaAppLoadingSpinner } from '@/seeka-labs-app-sdk-ui/shared/loading-spinner';
+import DeleteIcon from '@mui/icons-material/Delete';
+import RefreshIcon from '@mui/icons-material/Refresh';
+import { Alert, AlertTitle, Box, Button, Stack, Typography } from "@mui/material";
+import { appAccessTokenHeaderName, coreApiAccessTokenHeaderName } from '@seeka-labs/sdk-apps-core';
+import { useConfirm } from "material-ui-confirm";
+import { enqueueSnackbar } from 'notistack';
+import { useEffect, useState } from "react";
+import { useLocation } from "react-router-dom";
+
+export const TypeformLogin = ({ onChange }: { onChange: (linked: boolean) => void }) => {
+    // Get query string params from react-router-dom
+    const location = useLocation();
+    const appTokens = useTokens();
+    const searchParams = new URLSearchParams(location.search);
+    const error = searchParams.get('error') as 'invalid_scopes' | string | null;
+    const appBaseUrl = window.seekaAppConfig?.appBaseUrl || '';
+    const [loading, setLoading] = useState(false);
+    const [waitingForAuth, setWaitingForAuth] = useState(false);
+    const [hasUserAccessToken, setHasUserAccessToken] = useState(window.seekaAppConfig.state?.hasUserAccessToken || false)
+
+    const confirm = useConfirm();
+
+    let errorMessage: string | null = null;
+    if (error === 'invalid_scopes') {
+        errorMessage = 'Invalid permissions granted. Click the button below to try again ensuring to select all permissions when logging into Typeform.';
+    }
+    else {
+        errorMessage = error;
+    }
+
+    const typeformLogin = async () => {
+        setLoading(true)
+        setWaitingForAuth(true)
+        window.seekaAppConfig.state.hasUserAccessToken = false;
+        window.open(appBaseUrl + '/api/auth/redirect/typeform?seekaAppId=' + window.seekaAppConfig.seekaAppId + '&seekaAppInstallId=' + window.seekaAppConfig.seekaAppInstallId);
+    }
+
+    const disconnect = async (reauth: boolean) => {
+        confirm()
+            .then(async () => {
+                setLoading(true)
+                let success = false;
+                try {
+                    const response = await fetch(window.seekaAppConfig.appBaseUrl + '/app/api/typeform/auth', {
+                        method: 'DELETE',
+                        headers: {
+                            'Content-Type': 'application/json',
+                            [appAccessTokenHeaderName]: 'Bearer ' + appTokens?.appAccessToken,
+                            [coreApiAccessTokenHeaderName]: 'Bearer ' + appTokens?.coreApiAccessToken,
+                        }
+                    })
+                    if (response.ok) {
+                        success = true;
+                    }
+                }
+                catch (error) {
+                    console.error(error);
+                }
+                finally {
+                    setLoading(false)
+                }
+                if (success) {
+                    enqueueSnackbar('Disconnected', { variant: 'success' });
+
+                    window.seekaAppConfig.state.hasUserAccessToken = false;
+                    onChange(false)
+                    setHasUserAccessToken(false)
+
+                    if (reauth) typeformLogin()
+                }
+                else {
+                    enqueueSnackbar('Failed', { variant: 'error' });
+                }
+            })
+            .catch(() => { });
+    }
+
+    const checkLinkedUser = async () => {
+        const response = await fetch(window.seekaAppConfig.appBaseUrl + '/app/api/typeform/auth', {
+            method: 'GET',
+            headers: {
+                [appAccessTokenHeaderName]: 'Bearer ' + appTokens?.appAccessToken,
+                [coreApiAccessTokenHeaderName]: 'Bearer ' + appTokens?.coreApiAccessToken,
+            }
+        })
+        const res: { hasUserAccessToken: boolean } | null = await response.json()
+        if (res && res.hasUserAccessToken) {
+            setWaitingForAuth(false)
+            setLoading(false)
+            window.seekaAppConfig.state.hasUserAccessToken = res?.hasUserAccessToken || false
+
+            onChange(window.seekaAppConfig.state.hasUserAccessToken)
+            setHasUserAccessToken(window.seekaAppConfig.state.hasUserAccessToken)
+        }
+    }
+
+    let timer: NodeJS.Timeout | null = null;
+    useEffect(() => {
+        if (waitingForAuth) {
+            if (!timer) setTimeout(() => { timer = setInterval(checkLinkedUser, 2000) }, 2000)
+        }
+        else {
+            if (timer) {
+                clearInterval(timer)
+            }
+        }
+
+        return () => {
+            if (timer) {
+                clearInterval(timer)
+            }
+        }
+    }, [waitingForAuth])
+
+    return (
+        waitingForAuth ? (
+            <Stack gap={1} direction="column">
+                <SeekaAppLoadingSpinner>Waiting for auth</SeekaAppLoadingSpinner>
+                <Button variant="text" onClick={() => setWaitingForAuth(false)}>Cancel</Button>
+            </Stack>
+        ) : (
+            <Stack gap={2}>
+                {hasUserAccessToken && <Typography variant="body2">Currently authenticated</Typography>}
+                <Box>
+                    {hasUserAccessToken ? (
+                        <Button color="primary" variant="text" size={'small'} loading={loading} onClick={() => disconnect(true)} endIcon={<RefreshIcon />}>Reauthenticate</Button>
+                    ) : (
+                        <Button color="primary" variant="contained" loading={loading} onClick={typeformLogin}>Authenticate Typeform</Button>
+                    )}
+                    {hasUserAccessToken && <Button color="error" variant="text" size={'small'} loading={loading} onClick={() => disconnect(false)} endIcon={<DeleteIcon />}>Disconnect</Button>}
+                </Box>
+                {errorMessage && <Alert severity="error"><AlertTitle>Authentication error</AlertTitle>{errorMessage}</Alert>}
+
+            </Stack>
+        )
+    );
+}

package/dist/ai-context/internal/examples/v2/typeform/app/ui/src/index.tsx

@@ -0,0 +1,45 @@
+import CssBaseline from '@mui/material/CssBaseline';
+import { ThemeProvider } from '@mui/material/styles';
+import { SnackbarProvider } from 'notistack';
+import * as React from 'react';
+import * as ReactDOM from 'react-dom/client';
+import App from './App';
+
+import { fetchBaseQuery } from '@reduxjs/toolkit/query';
+import { setBaseQueryFn } from '@seeka-labs-internal/lib-react-common';
+import { appAccessTokenQueryParamName, coreApiAccessTokenQueryParamName } from '@seeka-labs/sdk-apps-core';
+import queryString from 'query-string';
+import { SeekaAppMaterialUiTheme } from './seeka-labs-app-sdk-ui/shared/theme';
+
+setBaseQueryFn(
+  fetchBaseQuery({
+    baseUrl: (import.meta as any).env.VITE_URLS_SEEKA_API_CORE || "https://api.seeka.services",
+    prepareHeaders(headers, api) {
+      const searchParams = new URLSearchParams(location.search);
+      const appAccessToken = searchParams.get(appAccessTokenQueryParamName);
+      const coreApiAccessToken = searchParams.get(coreApiAccessTokenQueryParamName);
+
+      headers.set('Authorization', 'Bearer ' + coreApiAccessToken);
+      return headers;
+    },
+    paramsSerializer(params) {
+      return queryString.stringify(params);
+    },
+  })
+);
+
+const rootElement = document.getElementById('root');
+const root = ReactDOM.createRoot(rootElement!);
+
+root.render(
+  <React.StrictMode>
+    <ThemeProvider theme={SeekaAppMaterialUiTheme}>
+      <CssBaseline />
+
+      <SnackbarProvider anchorOrigin={{ horizontal: 'right', vertical: 'top' }} >
+        <App />
+      </SnackbarProvider>
+
+    </ThemeProvider>
+  </React.StrictMode>
+);

package/dist/ai-context/internal/examples/v2/typeform/app/ui/src/routes/home/index.tsx

@@ -0,0 +1,10 @@
+import { SetupSteps } from "@/components/setup/steps";
+import { Container } from "@mui/material";
+
+export const Index = () => {
+    return (
+        <Container maxWidth='xl'>
+            <SetupSteps />
+        </Container>
+    );
+}

package/dist/ai-context/internal/examples/v2/typeform/app/ui/src/seeka-labs-app-sdk-ui/api/redux/index.tsx

@@ -0,0 +1,16 @@
+import { createStore } from '@seeka-labs-internal/lib-react-common';
+import React from 'react';
+
+import { Provider as ReduxProvider } from 'react-redux';
+
+
+const store = createStore();
+export const SeekaCoreApiReduxProvider = ({ children }: { children: React.ReactNode }) => {
+
+    return (
+        <ReduxProvider store={store}>
+
+            {children}
+        </ReduxProvider>
+    )
+}

package/dist/ai-context/internal/examples/v2/typeform/app/ui/src/seeka-labs-app-sdk-ui/shared/auth/tokenProvider/index.tsx

@@ -0,0 +1,53 @@
+const parentOrigin = (import.meta as any).env.VITE_URLS_SEEKA_APP_CORE_ORIGIN as string
+
+import { appAccessTokenQueryParamName, coreApiAccessTokenQueryParamName } from '@seeka-labs/sdk-apps-core';
+import React, { createContext, useEffect, useState } from 'react';
+
+import { useLocation } from "react-router-dom";
+
+interface Tokens { appAccessToken: string; coreApiAccessToken: string }
+
+export const TokenContext = createContext<Tokens | null>(null)
+
+export const TokenProvider = ({ children }: { children: React.ReactNode }) => {
+    const [tokens, setTokens] = useState<Tokens | null>({ appAccessToken: '', coreApiAccessToken: '' })
+    const location = useLocation();
+
+    useEffect(() => {
+        function handleMessage(evt: MessageEvent) {
+            if (evt.origin !== parentOrigin) return
+            if (evt.data?.type === 'TOKENS') {
+                setTokens({
+                    appAccessToken: evt.data.appAccessToken,
+                    coreApiAccessToken: evt.data.coreApiAccessToken
+                })
+            }
+        }
+
+        window.addEventListener('message', handleMessage)
+        // request once
+        window.parent.postMessage({ type: 'REQUEST_TOKENS' }, parentOrigin)
+
+        return () => {
+            window.removeEventListener('message', handleMessage)
+        }
+    }, [parentOrigin])
+
+    useEffect(() => {
+        const searchParams = new URLSearchParams(location.search);
+        const appAccessToken = searchParams.get(appAccessTokenQueryParamName);
+        const coreApiAccessToken = searchParams.get(coreApiAccessTokenQueryParamName);
+        if (appAccessToken && coreApiAccessToken) {
+            setTokens({
+                appAccessToken,
+                coreApiAccessToken
+            });
+        }
+    }, [])
+
+    return (
+        <TokenContext.Provider value={tokens}>
+            {children}
+        </TokenContext.Provider>
+    )
+}

package/dist/ai-context/internal/examples/v2/typeform/app/ui/src/seeka-labs-app-sdk-ui/shared/auth/useTokens/index.ts

@@ -0,0 +1,8 @@
+import { useContext } from "react"
+import { TokenContext } from "../tokenProvider"
+
+export function useTokens() {
+    const ctx = useContext(TokenContext)
+    if (ctx === null) throw new Error('useTokens must be inside <TokenProvider>')
+    return ctx
+}