@seeka-labs/cli-apps 3.7.0 → 3.8.2

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

@@ -0,0 +1,237 @@
+import { TrackingActivityNames } from '@seeka-labs-internal/lib-api-app';
+import { useMemo, useState } from 'react';
+
+
+import { SxProps } from '@mui/system';
+// import { RhfAutocomplete, RhfAutocompleteOption } from '@seeka-labs-internal/lib-react-common';
+import { RhfAutocomplete, RhfAutocompleteOption } from '@seeka-labs-internal/lib-react-common';
+import { getActivityName } from '@seeka-labs/converge';
+import { isArray } from 'lodash-es';
+import { ActivityNameItem, CustomActivityNameLabelPrefix, CustomExactActivityNameLabelPrefix } from '../../utils';
+type ActivityNameSelectProps = {
+    // error: boolean
+    activityNames: ActivityNameItem[]
+    name: string
+    multiple?: boolean
+    stringValues?: boolean
+    // blurOnSelect?: boolean
+    label?: string
+    sx?: SxProps
+    // onChange?: (activityNames: ActivityNameItem[] | ActivityNameItem) => void
+    // selectedActivityNames?: ActivityNameItem[] | ActivityNameItem | null
+    // selectedActivityNamesString?: string[] | string | null
+    allowCustomActivity?: boolean
+}
+
+const getCustomOption = (inputValue: string, prefix: boolean): ActivityNameItem => ({
+    activityName: TrackingActivityNames.Custom,
+    activityNameCustom: inputValue,
+    key: inputValue,
+    label: `${prefix ? CustomActivityNameLabelPrefix : ''}${inputValue}`,
+})
+
+
+const getCustomActivityOverrideOption = (inputValue: string, prefix: boolean): ActivityNameItem => {
+    const standardActivityName = getActivityName(inputValue);
+    return {
+        activityName: standardActivityName,
+        activityNameCustom: standardActivityName === TrackingActivityNames.Custom ? inputValue : undefined,
+        key: inputValue,
+        activityNameOverride: inputValue,
+        label: `${prefix ? CustomExactActivityNameLabelPrefix : ''}${inputValue}`,
+    }
+}
+
+export const ActivityNameSelect = ({
+    activityNames,
+    // error,
+    // selectedActivityNames,
+    multiple,
+    label,
+    // blurOnSelect,
+    name,
+    sx,
+    // onChange,
+    allowCustomActivity,
+    stringValues,
+    // selectedActivityNamesString,
+}: ActivityNameSelectProps) => {
+
+    const [selectedValueState, setSelectedValueState] = useState<ActivityNameItem[] | ActivityNameItem>(multiple ? [] : null as any)
+        // const [selectedValueState, setSelectedValueState] = useState<ActivityNameItem[] | ActivityNameItem>(multiple ? [] : null as any)
+
+        // const selectedValues = useMemo(() => {
+        //   return enumerateSelected() as ActivityNameItem[] | ActivityNameItem
+        // }, [selectedActivityNames, selectedActivityNamesString, activityNames])
+        ;
+    const activityNameOptions: RhfAutocompleteOption[] = useMemo(() => {
+        let selectedState: ActivityNameItem[];
+        if (selectedValueState) {
+            if (isArray(selectedValueState)) {
+                selectedState = selectedValueState
+            }
+            else {
+                selectedState = [selectedValueState]
+            }
+        }
+        else {
+            selectedState = []
+        }
+        // if (!selectedValueState) return activityNames;
+
+        const newActivityNames = [...activityNames];
+
+        selectedState.forEach(e => {
+            if (!newActivityNames.find(a => a.key.toLowerCase() === e.key.toLowerCase())) {
+                newActivityNames.push(e)
+            }
+        })
+
+        // Handle default string values
+        // if (selectedActivityNamesString) {
+        //     if (isArray(selectedActivityNamesString)) {
+        //         selectedActivityNamesString.forEach(e => {
+        //             if (!newActivityNames.find(a => a.key.toLowerCase() === e.toLowerCase())) {
+        //                 newActivityNames.push(getCustomOption(e, true))
+        //             }
+        //         })
+        //     }
+        //     else {
+        //         // console.log('heree selectedActivityNamesString', selectedActivityNamesString)
+        //         const toFind = selectedActivityNamesString?.toLowerCase()
+        //         if (!newActivityNames.find(a => a.key.toLowerCase() === toFind)) {
+        //             newActivityNames.push(getCustomOption(selectedActivityNamesString, true))
+        //         }
+        //     }
+        // }
+        // console.log('heree newActivityNames', newActivityNames)
+
+        return newActivityNames.map(e => ({
+            title: e.label,
+            inputValue: e.key,
+            isCustomInputValue: Boolean(e.activityNameCustom)
+        }));
+    }, [activityNames, selectedValueState, stringValues])
+
+    // const enumerateSelected = (): ActivityNameItem[] | ActivityNameItem | null => {
+    //     if (selectedActivityNames) {
+    //         if (isArray(selectedActivityNames)) {
+    //             if (multiple) {
+    //                 return selectedActivityNames
+    //             }
+    //             else {
+    //                 if (selectedActivityNames.length > 0) {
+    //                     return selectedActivityNames[0]
+    //                 }
+    //                 else {
+    //                     return null
+    //                 }
+    //             }
+    //         }
+    //         else {
+    //             if (multiple) {
+    //                 return [selectedActivityNames]
+    //             }
+    //             else {
+    //                 return selectedActivityNames
+    //             }
+    //         }
+    //     }
+
+    //     if (selectedActivityNamesString) {
+    //         const toFind = (isArray(selectedActivityNamesString) ? selectedActivityNamesString : [selectedActivityNamesString]).map(e => e?.toLowerCase()).filter(Boolean)
+
+    //         const vals = activityNameOptions?.filter(e => toFind.find(a => a === e.key?.toLowerCase() || a === e.activityName?.toString()?.toLowerCase())) || []
+
+    //         // console.log('heree toFind', toFind, activityNameOptions, vals)
+    //         return multiple ? [...vals] : (vals.length > 0 ? { ...vals[0] } : null)
+    //     }
+
+    //     return multiple ? [] : null
+    // }
+
+    // const isOptionEqualToValue = (option: ActivityNameItem, value: ActivityNameItem) => {
+    //     if (!option.activityNameOverride && !value.activityNameOverride) {
+    //         return option.key.toLowerCase() === value.key.toLowerCase()
+    //     }
+    //     return option.key.toLowerCase() === value.key.toLowerCase() && option.activityNameOverride === value.activityNameOverride
+    // }
+
+    // useEffect(() => {
+    //     setSelectedValueState(enumerateSelected() as ActivityNameItem[] | ActivityNameItem)
+    // }, [])
+
+    // if (selectedActivityNamesString) {
+    //     // console.log('heree selectedActivityNamesString', selectedValueState, selectedActivityNamesString, activityNameOptions)
+    // }
+    // else {
+    //     // console.log('heree selectedActivityNames', selectedValueState, selectedActivityNames, activityNameOptions)
+    // }
+
+    // console.log('heree this.state.value', activityNameOptions, selectedValueState, multiple)
+
+    return (
+        (<RhfAutocomplete
+            name={name}
+            disableClearable
+            options={activityNameOptions}
+            // handleHomeEndKeys
+            multiple={multiple}
+            isStringValue={stringValues}
+            freeSoloOptionPrefix={CustomActivityNameLabelPrefix}
+            label={label}
+            freeSolo={allowCustomActivity}
+            // autoFocus
+            // blurOnSelect={blurOnSelect}
+            //   freeSolo
+            sx={{
+                display: 'inline-block',
+                // width: !width ? (!multiple ? '220px' : (220 + (170 * ((selectedValueState as []).length - 1))) + 'px') : width,
+                minWidth: '250px',
+                ...sx
+            }}
+        // getOptionLabel={(option) => lookupActivityName(option.key).label}
+        // getOptionLabel={(option) => {
+        //     return (option as ActivityNameItem).label
+        // }}
+        // isOptionEqualToValue={isOptionEqualToValue}
+        // filterOptions={(options, params) => {
+        //     const inputValLower = params.inputValue.toLowerCase();
+        //     const filtered = options.filter((e) =>
+        //         e.label.toLowerCase().includes(inputValLower) || e.key.toLowerCase().includes(inputValLower)
+        //     )
+
+        //     // Suggest the creation of a new value
+        //     if (params.inputValue !== '' && getActivityName(params.inputValue) === TrackingActivityNames.Custom) {
+        //         filtered.push(getCustomOption(params.inputValue, true))
+        //     }
+        //     if (params.inputValue !== '' && allowCustomActivity) {
+        //         filtered.push(getCustomActivityOverrideOption(params.inputValue, true))
+        //     }
+
+        //     return filtered
+        // }}
+        // value={selectedValueState}
+        // onChange={(_e, value) => {
+        //     // console.log('heree onchange', value)
+        //     setSelectedValueState(value)
+        //     if (onChange) {
+        //         onChange(value)
+        //     }
+        // }}
+        // renderInput={(params) => (
+        //     <TextField
+        //         {...params}
+        //         margin="normal"
+        //         error={error}
+        //         size="small"
+        //         label={label}
+        //         variant="standard"
+        //         slotProps={{
+        //             input: { ...params.InputProps, type: 'text' }
+        //         }}
+        //     />
+        // )}
+        />)
+    );
+}

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

@@ -0,0 +1,135 @@
+import {
+    ActivityPipelineActivityFilterSourceItemType
+} from '@seeka-labs-internal/lib-api-app';
+
+import { sentenceCase } from '@/seeka-labs-app-sdk-ui/utils';
+import { ActivityPipelineActivityFilterSourceItem, RhfAutocomplete, TextMatchInfo } from '@seeka-labs-internal/lib-react-common';
+import { useMemo } from 'react';
+import { useFormContext } from 'react-hook-form';
+
+type ActivityPipelineActivityFilterSourceItemOption = {
+    label: string;
+    type: ActivityPipelineActivityFilterSourceItemType;
+    key: string;
+    textMatch: TextMatchInfo | null;
+};
+
+
+type ActivitySourceSelectProps = {
+    sourceLookupValues: ActivityPipelineActivityFilterSourceItem[]
+    //   sourceFilter: ActivityPipelineActivitySourceFilter
+    name: string
+    //   onChange: (filter: ActivityPipelineActivitySourceFilter) => void
+    //   error: boolean
+    readOnly?: boolean
+    fullWidth?: boolean
+    helperText?: string;
+    disablePortal?: boolean
+    disableClearable?: boolean
+    size?: 'small' | 'medium'
+    blurOnSelect?: boolean
+}
+
+export const ActivitySourceSelect = ({
+    sourceLookupValues,
+    name,
+    //   sourceFilter,
+    //   error,
+    size,
+    readOnly,
+    disableClearable,
+    fullWidth,
+    disablePortal,
+    helperText,
+    blurOnSelect,
+    //   onChange,
+}: ActivitySourceSelectProps) => {
+    const { watch, setValue } = useFormContext();
+    //   const sourceFilterValue: ActivityPipelineActivitySourceFilter = {
+    //     ...sourceFilter,
+    //     filters: sourceFilter.filters || [],
+    //   } as ActivityPipelineActivitySourceFilter
+    // const sourceFilterValue = watch(name)
+
+    // console.log('heree this.state.value', sourceLookupValues)
+
+    const sourceLookupValuesSorted = useMemo(() => {
+        return [...(sourceLookupValues || [])].sort((a, b) => {
+            if (a.type?.toLowerCase() === b.type?.toLowerCase()) {
+                return (a.label?.toLowerCase() || 5) > (b.label?.toLowerCase() || 5) ? 1 : -1
+            }
+            return (a.type?.toLowerCase() || 5) < (b.type?.toLowerCase() || 5) ? 1 : -1
+        }) as ActivityPipelineActivityFilterSourceItemOption[]
+    }, [sourceLookupValues])
+
+    // console.log('heree this.state.value2', sourceLookupValuesSorted, sourceFilterValue)
+
+    return (
+        <RhfAutocomplete<ActivityPipelineActivityFilterSourceItemOption, true, false>
+            name={name}
+            disableClearable={disableClearable}
+            multiple
+            disablePortal={disablePortal}
+            readOnly={readOnly}
+            options={sourceLookupValuesSorted}
+            autoHighlight
+            blurOnSelect={blurOnSelect}
+            clearOnBlur
+            sx={{
+                display: 'inline-block',
+                minWidth: '180px',
+            }}
+            // fullWidth
+            // renderTags={(value, getTagProps) =>
+            //     value.map((option, index) => {
+            //         const p = getTagProps({ index })
+            //         return (
+            //             <Chip
+            //                 label={option.label}
+            //                 {...p}
+            //                 key={p.key}
+            //                 deleteIcon={sourceFilterValue.length === 1 ? <></> : undefined}
+            //             />
+            //         )
+            //     })
+            // }
+            groupBy={(option) => sentenceCase(option.type?.toString() || '')}
+            // defaultValue={[sourceLookupValues[0]]}
+            // value={}
+            // style={{ display: 'inline-block', width: '250px', marginRight: '10px' }}
+            getOptionLabel={(option) => (option as ActivityPipelineActivityFilterSourceItemOption).label as string}
+            isOptionEqualToValue={(option, value) =>
+                option.key.toLowerCase() === value.key.toLowerCase() &&
+                option.type.toLowerCase() === value.type.toLowerCase()
+            }
+            onChangeValue={(nVal) => {
+                let newValue = [...(nVal as ActivityPipelineActivityFilterSourceItemOption[])]
+                if (newValue === null || newValue.length === 0) {
+                    newValue = [sourceLookupValuesSorted[0]]
+                } else if (
+                    newValue.length > 1 &&
+                    newValue.findIndex(
+                        (e) => e.type === ActivityPipelineActivityFilterSourceItemType.Wildcard
+                    ) ===
+                    newValue.length - 1
+                ) {
+                    // Remove all but wildcard
+                    newValue = newValue.filter(
+                        (e) => e.type === ActivityPipelineActivityFilterSourceItemType.Wildcard
+                    )
+                } else if (
+                    newValue.find(
+                        (e) => e.type !== ActivityPipelineActivityFilterSourceItemType.Wildcard
+                    )
+                ) {
+                    // Remove wildcard
+                    newValue = newValue.filter(
+                        (e) => e.type !== ActivityPipelineActivityFilterSourceItemType.Wildcard
+                    )
+                }
+
+                setValue(name, newValue);
+            }}
+        />
+    );
+}

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

@@ -0,0 +1,16 @@
+import { ReactNode } from 'react';
+import { FormProvider as Form, UseFormReturn } from 'react-hook-form';
+
+type Props = {
+    children: ReactNode;
+    methods: UseFormReturn<any>;
+    onSubmit?: VoidFunction;
+};
+
+export function FormProvider({ children, onSubmit, methods }: Props) {
+    return (
+        <Form {...methods}>
+            <form onSubmit={onSubmit} style={{ marginLeft: 0, width: '100%' }}>{children}</form>
+        </Form>
+    );
+}

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

@@ -0,0 +1,133 @@
+import { sentenceCaseWithLowercase } from "@/seeka-labs-app-sdk-ui/utils"
+import { TrackingActivityNames } from "@seeka-labs-internal/lib-api-app"
+import { getActivityName } from "@seeka-labs/converge"
+import { forIn, sortBy } from "lodash-es"
+
+export const CustomActivityNameLabelPrefix = 'Custom: '
+export const CustomExactActivityNameLabelPrefix = 'Exact: '
+
+
+export const eventNameMapping = {
+    AddPaymentInfo: 'Add payment info',
+    AddToCart: 'Add to cart',
+    AddToWishlist: 'Add to wishlist',
+    CompleteRegistration: 'Complete registration',
+    Contact: 'Contact',
+    CustomizeProduct: 'Customize product',
+    Donate: 'Donate',
+    FindLocation: 'Find location',
+    InitiateCheckout: 'Initiate checkout',
+    Lead: 'Lead',
+    PageView: 'Page view',
+    Purchase: 'Purchase',
+    Schedule: 'Schedule',
+    Search: 'Search',
+    StartTrial: 'Start trial',
+    SubmitApplication: 'Submit application',
+    Subscribe: 'Subscribe',
+    ViewContent: 'View content',
+    KeywordSearch: 'Keyword search',
+    AddPaymentMethod: 'Add payment method',
+    ViewProduct: 'View product',
+    ViewPage: 'View page',
+    Order: 'Order',
+    ViewContentItem: 'View content item',
+}
+
+
+export const getFriendlyEventName = (eventName: string, maxLength?: number) => {
+    let mappedEventName =
+        eventName in eventNameMapping
+            ? (eventNameMapping as any)[eventName]
+            : sentenceCaseWithLowercase(eventName)
+
+    if (maxLength && maxLength > 0) {
+        const shouldTruncateName = mappedEventName.length >= maxLength
+        mappedEventName = shouldTruncateName
+            ? `${mappedEventName.substring(0, maxLength)}...`
+            : mappedEventName
+    }
+
+    return mappedEventName;
+}
+
+export interface ActivityNameItem {
+    activityName: TrackingActivityNames
+    activityNameCustom?: string
+    label: string
+    key: string
+    activityNameOverride?: string
+}
+export function getActivityNames(
+    excludeActivityNames: TrackingActivityNames[],
+    overrideDefault?: string[],
+    alwaysIncludeDefault = false
+): ActivityNameItem[] {
+    const names: ActivityNameItem[] = []
+    const exclude = [
+        TrackingActivityNames.Undefined,
+        TrackingActivityNames.Custom,
+        TrackingActivityNames.PageViewOrganic,
+        TrackingActivityNames.PageViewUtmAttributed,
+        TrackingActivityNames.FilterItemsByAttribute,
+        TrackingActivityNames.ChangeProductAttribute,
+    ]
+
+    if (overrideDefault && overrideDefault.length > 0) {
+        const excludeAsString = exclude.map((x) => x.toString())
+        const excludeActivityNamesAsString = excludeActivityNames.map((x) => x.toString())
+        for (const value of overrideDefault) {
+            if (
+                excludeAsString.indexOf(value) > -1 ||
+                excludeActivityNamesAsString.indexOf(value) > -1
+            )
+                continue
+
+            const standardActivityName = getActivityName(value);
+            const label = getFriendlyEventName(value);
+
+            names.push({
+                activityName: standardActivityName,
+                activityNameCustom: standardActivityName === TrackingActivityNames.Custom ? value : undefined,
+                key: value,
+                label: standardActivityName === TrackingActivityNames.Custom ? CustomActivityNameLabelPrefix + label : label,
+            })
+        }
+    } else {
+        forIn(overrideDefault || TrackingActivityNames, (value, key) => {
+            if (exclude.indexOf(value) > -1 || excludeActivityNames.indexOf(value) > -1) return
+
+            const standardActivityName = getActivityName(value);
+            const label = getFriendlyEventName(value);
+
+            names.push({
+                activityName: standardActivityName,
+                activityNameCustom: standardActivityName === TrackingActivityNames.Custom ? value : undefined,
+                key: key,
+                label: standardActivityName === TrackingActivityNames.Custom ? CustomActivityNameLabelPrefix + label : label,
+            })
+        })
+    }
+
+    if (alwaysIncludeDefault && overrideDefault) {
+        forIn(TrackingActivityNames, (value, key) => {
+            if (
+                exclude.indexOf(value) > -1 ||
+                excludeActivityNames.indexOf(value) > -1 ||
+                names.find((e) => e.activityName === value)
+            ) {
+                return;
+            }
+
+            const standardActivityName = getActivityName(value);
+            names.push({
+                activityName: standardActivityName,
+                activityNameCustom: standardActivityName === TrackingActivityNames.Custom ? value : undefined,
+                key: key,
+                label: getFriendlyEventName(value),
+            })
+        })
+    }
+
+    return sortBy(names, 'label')
+}

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

@@ -0,0 +1,85 @@
+
+import { ConditionOperator } from '@seeka-labs-internal/lib-api-app'
+import { ActivityPipelineActivityFilter, ActivityPipelineActivityFilterSourceItem, ActivityPipelineActivityFilterSourceItemType, ActivityPipelineActivityFilterType, ActivityPipelineActivitySourceFilter, ConditionComparer, TextMatchInfo } from '@seeka-labs-internal/lib-react-common'
+import * as yup from 'yup'
+
+// first, helper arrays for your enums:
+const FilterTypes = Object.values(ActivityPipelineActivityFilterType) as ActivityPipelineActivityFilterType[]
+const Comparers = Object.values(ConditionComparer) as ConditionComparer[]
+const Operators = Object.values(ConditionOperator) as ConditionOperator[]
+const ItemTypes = Object.values(ActivityPipelineActivityFilterSourceItemType) as ActivityPipelineActivityFilterSourceItemType[]
+
+export const ActivityPipelineActivityFilterFormSchema = yup
+    .object<ActivityPipelineActivityFilter>()
+    .shape({
+        id: yup
+            .string()
+            .nonNullable()
+            .nullable(),
+        // enforce one of your enum values
+        type: yup
+            .mixed<ActivityPipelineActivityFilterType>()
+            .oneOf(FilterTypes, 'Invalid filter type')
+            .nonNullable()
+            .required('Filter type is required'),
+
+        // either activityNames OR sourceFilter (or both) must be present
+        activityNames: yup
+            .array()
+            .of(yup.string().required())
+            .min(1, 'Required')
+            .nonNullable()
+            .when('type', {
+                is: ActivityPipelineActivityFilterType.ActivityTracked,
+                then: s => s.required('Required'),
+            }),
+
+        sourceFilter: yup
+            .object<ActivityPipelineActivitySourceFilter>()
+            .nullable()
+            .shape({
+                comparer: yup
+                    .mixed<ConditionComparer>()
+                    .oneOf(Comparers)
+                    .required('Required'),
+                filters: yup
+                    .array()
+                    .of(
+                        yup
+                            .object<ActivityPipelineActivityFilterSourceItem>()
+                            .shape({
+                                label: yup.string().required('Label is required'),
+                                type: yup
+                                    .mixed<ActivityPipelineActivityFilterSourceItemType>()
+                                    .oneOf(ItemTypes)
+                                    .required('Item type is required'),
+                                key: yup
+                                    .string()
+                                    .nonNullable()
+                                    .when('textMatch', {
+                                        is: (tm: TextMatchInfo | undefined) => !tm,
+                                        then: s => s.required('Key is required if no textMatch given'),
+                                        otherwise: s => s,
+                                    }),
+                                textMatch: yup
+                                    .object<TextMatchInfo>()
+                                    .nullable()
+                                    .shape({
+                                        // adjust these to your TextMatchInfo shape
+                                        operator: yup
+                                            .mixed<ConditionOperator>()
+                                            .oneOf(Operators, 'Invalid operator')
+                                            .optional(),
+                                        matchValue: yup.string().optional(),
+                                    }),
+                            })
+                    )
+                    .min(1, 'Required'),
+                description: yup.string().optional(),
+            })
+            .when('activityNames', {
+                is: (names: string[] | undefined) => !(names && names.length),
+                then: s => s.required('Required'),
+            }),
+    })
+    .required('Required')

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

@@ -0,0 +1,13 @@
+import { Box, CircularProgress, Stack } from "@mui/material"
+import React from "react"
+
+export const SeekaAppLoadingSpinner = ({ children }: { children?: React.ReactNode }) => {
+    return (
+        <Box mt={4}>
+            <Stack gap={2} justifyContent={"center"}>
+                {children}
+                <center><CircularProgress /></center>
+            </Stack>
+        </Box>
+    )
+}

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

@@ -0,0 +1,24 @@
+
+import { MaterialUiTheme } from '@seeka-labs-internal/lib-react-common';
+
+import { createTheme } from '@mui/material/styles';
+import { deepmerge } from '@mui/utils';
+
+const bg = "rgb(249, 248, 248)"
+
+export const SeekaAppMaterialUiTheme = createTheme(deepmerge(MaterialUiTheme, {
+    palette: {
+        background: {
+            default: bg
+        },
+    },
+    components: {
+        MuiCssBaseline: {
+            styleOverrides: {
+                body: {
+                    backgroundColor: bg
+                },
+            },
+        },
+    },
+}));

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

@@ -0,0 +1,11 @@
+import { camelCase, startCase } from "lodash-es";
+
+export function sentenceCase(str: string) {
+    return startCase(camelCase(str))
+}
+
+export function sentenceCaseWithLowercase(str: string) {
+    const a = startCase(camelCase(str))
+
+    return a[0].toUpperCase() + a.slice(1).toLowerCase()
+}