@evoke-platform/ui-components 1.15.0 → 1.16.0

package/dist/published/components/custom/FormV2/FormRendererContainer.js

@@ -1,16 +1,17 @@
 import { useApiServices, useApp, useAuthenticationContext, useNavigate, useObject, } from '@evoke-platform/context';
 import { useQuery, useQueryClient } from '@tanstack/react-query';
 import axios from 'axios';
-import { cloneDeep, get, isArray, isEmpty, isEqual, omit, pick, set } from 'lodash';
-import React, { useEffect, useMemo, useRef, useState } from 'react';
+import { cloneDeep, get, isArray, isEmpty, isEqual, isObject, pick, set } from 'lodash';
+import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { Skeleton, Snackbar } from '../../core';
 import { Box } from '../../layout';
 import ErrorComponent from '../ErrorComponent';
 import ConditionalQueryClientProvider from './components/ConditionalQueryClientProvider';
 import { evalDefaultVals, processValueUpdate } from './components/DefaultValues';
 import Header from './components/Header';
-import { convertPropertiesToParams, createFileLinks, deleteDocuments, encodePageSlug, extractAllCriteria, extractPresetValuesFromCriteria, extractPresetValuesFromDynamicDefaultValues, formatSubmission, getEntryId, getPrefixedUrl, getUnnestedEntries, isAddressProperty, isEmptyWithDefault, plainTextToRtf, useFormById, } from './components/utils';
+import { convertPropertiesToParams, createFileLinks, deleteDocuments, encodePageSlug, extractAllCriteria, extractPresetValuesFromCriteria, extractPresetValuesFromDynamicDefaultValues, formatSubmission, getEntryId, getPrefixedUrl, getUnnestedEntries, handleFileUpload, isAddressProperty, isEmptyWithDefault, plainTextToRtf, useFormById, } from './components/utils';
 import FormRenderer from './FormRenderer';
+import { DepGraph } from 'dependency-graph';
 // Wrapper to provide QueryClient context for FormRendererContainer if this is not a nested form
 function FormRendererContainer(props) {
     return (React.createElement(ConditionalQueryClientProvider, null,
@@ -23,7 +24,7 @@ function FormRendererContainerInner(props) {
     const navigateTo = useNavigate();
     const queryClient = useQueryClient();
     const { id: appId } = useApp();
-    const [parameters, setParameters] = useState();
+    const [parameters, setParameters] = useState([]);
     const formDataRef = useRef();
     // We only need the setter to force a re-render when form data updates; the value itself
     // is intentionally not referenced elsewhere to avoid stale reads (we use formDataRef).
@@ -53,7 +54,54 @@ function FormRendererContainerInner(props) {
     const [isSaving, setIsSaving] = useState(false);
     const [lastSavedData, setLastSavedData] = useState({});
     const [uniquePresetValues, setUniquePresetValues] = useState([]);
-    const flattenFormEntries = useMemo(() => getUnnestedEntries(form?.entries || []), [form?.entries]);
+    const flattenFormEntries = useMemo(() => {
+        const graph = new DepGraph({ circular: true });
+        const unnestedEntries = getUnnestedEntries(form?.entries || []);
+        const nonInputEntries = [];
+        for (const entry of unnestedEntries) {
+            const entryId = getEntryId(entry);
+            if (entryId && entry.type !== 'readonlyField') {
+                graph.addNode(entryId, entry);
+            }
+            else {
+                nonInputEntries.push(entry);
+            }
+        }
+        for (const entry of unnestedEntries) {
+            const entryId = getEntryId(entry);
+            if (entryId && (entry.type === 'input' || entry.type === 'inputField')) {
+                const { defaultValue } = entry.display || {};
+                let presetValues = [];
+                if (typeof defaultValue === 'string') {
+                    presetValues = extractPresetValuesFromDynamicDefaultValues([entry]);
+                }
+                else if (isObject(defaultValue) && 'criteria' in defaultValue && !isEmpty(defaultValue.criteria)) {
+                    presetValues = extractPresetValuesFromCriteria(defaultValue.criteria);
+                }
+                presetValues.forEach((presetValue) => {
+                    const fragments = presetValue.replace(/{{{input.|}}}|{{input.|}}/g, '').split('.');
+                    // preset value references top level fields i.e name or dateOfBirth
+                    if (fragments.length === 1 && graph.hasNode(fragments[0])) {
+                        graph.addDependency(entryId, fragments[0]);
+                    }
+                    else if (fragments.length > 1) {
+                        // preset value references nested fields i.e address.line1 or person.address.line1
+                        const addressKeys = ['line1', 'line2', 'city', 'county', 'state', 'zipCode', 'country'];
+                        if (addressKeys.includes(fragments[1]) && graph.hasNode(`${fragments[0]}.${fragments[1]}`)) {
+                            graph.addDependency(entryId, `${fragments[0]}.${fragments[1]}`);
+                        }
+                        else if (graph.hasNode(fragments[0])) {
+                            graph.addDependency(entryId, fragments[0]);
+                        }
+                    }
+                });
+            }
+        }
+        return graph
+            .overallOrder()
+            .map((id) => graph.getNodeData(id))
+            .concat(nonInputEntries);
+    }, [form?.entries]);
     const userAccount = useAuthenticationContext()?.account;
     const objectStore = useObject(form?.objectId ?? objectId);
     const onError = (err) => {
@@ -71,7 +119,7 @@ function FormRendererContainerInner(props) {
     });
     // trigger refetch on success
     const { data: instance, error: instanceError } = useQuery({
-        queryKey: [objectId, instanceId, 'instance'],
+        queryKey: [objectId, instanceId, 'instance', uniquePresetValues],
         queryFn: async () => {
             const instance = await apiServices.get(getPrefixedUrl(`/objects/${objectId}/instances/${instanceId}`), {
                 params: {
@@ -93,6 +141,93 @@ function FormRendererContainerInner(props) {
         staleTime: Infinity,
         enabled: !!instanceId && !!sanitizedObject,
     });
+    const getDefaultValues = useCallback(async (unnestedEntries, instanceData) => {
+        const result = cloneDeep(instanceData);
+        for (const entry of unnestedEntries) {
+            const fieldId = getEntryId(entry);
+            if (!fieldId)
+                continue;
+            const fieldValue = get(result, fieldId);
+            if ((entry.type === 'input' || entry.type === 'inputField') &&
+                isAddressProperty(entry.parameterId || entry.input?.id)) {
+                if ((isEmpty(result) || fieldValue === undefined || fieldValue === null || fieldValue === '') &&
+                    entry?.display?.defaultValue &&
+                    parameters) {
+                    const defaultValuesArray = await evalDefaultVals(parameters, entry, fieldValue, fieldId, apiServices, userAccount, result);
+                    if (isArray(defaultValuesArray)) {
+                        defaultValuesArray.forEach(({ fieldId, fieldValue }) => {
+                            set(result, fieldId, fieldValue);
+                        });
+                    }
+                }
+                else if (fieldValue !== undefined && fieldValue !== null) {
+                    set(result, fieldId, fieldValue);
+                }
+            }
+            else if (entry.type !== 'sections' && entry.type !== 'columns' && entry.type !== 'content') {
+                const parameter = parameters?.find((param) => param.id === fieldId);
+                if (associatedObject &&
+                    'propertyId' in associatedObject &&
+                    associatedObject?.propertyId === fieldId &&
+                    associatedObject?.instanceId &&
+                    (parameter || associatedObject.objectId) &&
+                    action?.type === 'create') {
+                    try {
+                        const instance = await apiServices.get(getPrefixedUrl(`/objects/${parameter?.objectId || associatedObject.objectId}/instances/${associatedObject.instanceId}`), {
+                            params: {
+                                expand: uniquePresetValues.filter((value) => value.startsWith(`{{{input.${fieldId}.`) ||
+                                    value.startsWith(`{{input.${fieldId}.`)),
+                            },
+                        });
+                        result[associatedObject.propertyId] = instance;
+                    }
+                    catch (error) {
+                        console.error(error);
+                    }
+                }
+                else if (entry.type === 'formlet') {
+                    // TODO: this should eventually fetch the formletId then get the fields and default values of those fields
+                }
+                else if (entry.type !== 'readonlyField') {
+                    if (isEmptyWithDefault(fieldValue, entry, result)) {
+                        if (fieldId && parameters && parameters.length > 0) {
+                            const defaultValuesArray = await evalDefaultVals(parameters, entry, fieldValue, fieldId, apiServices, userAccount, result);
+                            for (const { fieldId, fieldValue } of defaultValuesArray) {
+                                const parameter = parameters?.find((param) => param.id === fieldId);
+                                if (parameter?.type === 'object') {
+                                    const dependentFields = await processValueUpdate(unnestedEntries, parameters, fieldValue, apiServices, fieldId, formDataRef.current, userAccount);
+                                    for (const field of dependentFields) {
+                                        set(result, field.fieldId, field.fieldValue);
+                                    }
+                                }
+                                set(result, fieldId, fieldValue);
+                            }
+                        }
+                    }
+                    else if (parameter?.type === 'boolean' && (fieldValue === undefined || fieldValue === null)) {
+                        result[fieldId] = false;
+                    }
+                    else if (parameter?.type === 'fileContent' &&
+                        (fieldValue === undefined || fieldValue === null)) {
+                        result[fieldId] = instanceData['name'] ? new File([], instanceData['name']) : undefined;
+                    }
+                    else if (fieldValue !== undefined && fieldValue !== null) {
+                        if (parameter?.type === 'richText' && typeof fieldValue === 'string') {
+                            let RTFFieldValue = fieldValue;
+                            if (!fieldValue.trim().startsWith('{\\rtf')) {
+                                RTFFieldValue = plainTextToRtf(fieldValue);
+                            }
+                            result[fieldId] = RTFFieldValue;
+                        }
+                        else {
+                            result[fieldId] = fieldValue;
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }, [action, parameters, associatedObject, uniquePresetValues, formDataRef, apiServices, userAccount]);
     useEffect(() => {
         if (!sanitizedObject)
             return;
@@ -113,7 +248,7 @@ function FormRendererContainerInner(props) {
         else {
             setError('Action could not be found');
         }
-    }, [sanitizedObject, actionId, form?.actionId, instanceId]);
+    }, [sanitizedObject, actionId, form?.actionId, instanceId, flattenFormEntries, parameters]);
     const { data: navigationSlug } = useQuery({
         queryKey: [appId, 'navigationSlug'],
         queryFn: () => apiServices.get(getPrefixedUrl(`/apps/${appId}/pages/${encodePageSlug(pageNavigation)}`)),
@@ -159,11 +294,12 @@ function FormRendererContainerInner(props) {
             onError(error);
     }, [sanitizedObjectError, fetchedFormError, instanceError]);
     useEffect(() => {
-        if (!form)
+        if (!form || !action)
             return;
         // If no parameters are defined, then the action is synced with object properties
-        const getParamsFromObject = sanitizedObject && !action?.parameters;
-        setParameters(getParamsFromObject ? convertPropertiesToParams(sanitizedObject) : action?.parameters);
+        const getParamsFromObject = sanitizedObject && !action.parameters;
+        const parameters = (getParamsFromObject ? convertPropertiesToParams(sanitizedObject) : action.parameters) ?? [];
+        setParameters(parameters.filter((param) => param.type !== 'collection' && !param.formula));
     }, [form, action?.parameters, sanitizedObject]);
     useEffect(() => {
         const getInitialValues = async () => {
@@ -175,7 +311,7 @@ function FormRendererContainerInner(props) {
             }
         };
         getInitialValues();
-    }, [instanceId, instance, flattenFormEntries]);
+    }, [instanceId, instance, flattenFormEntries, getDefaultValues]);
     const onSubmissionSuccess = (updatedInstance) => {
         setSnackbarError({
             showAlert: true,
@@ -198,138 +334,98 @@ function FormRendererContainerInner(props) {
             });
         }
     };
+    /**
+     * Manually links any newly uploaded files in the submission to the specified instance.
+     * @param submission The form submission data
+     * @param linkTo The instance to link the files to
+     */
     const linkFiles = async (submission, linkTo) => {
-        // Create file links for any uploaded files after instance creation
+        // Create file links for any uploaded files that haven't been linked yet
         for (const property of sanitizedObject?.properties?.filter((property) => property.type === 'file') ?? []) {
             const files = submission[property.id];
             if (files?.length) {
-                try {
-                    await createFileLinks(files, linkTo, apiServices);
-                }
-                catch (error) {
-                    console.error('Failed to create file links:', error);
-                    // Don't fail the entire submission if file linking fails
+                // Only link files that have the 'unsaved' flag (newly uploaded, not yet linked)
+                const unsavedFiles = files.filter((file) => file.unsaved);
+                if (unsavedFiles.length) {
+                    await createFileLinks(unsavedFiles, linkTo, apiServices);
                 }
             }
         }
     };
+    /**
+     * Strips unsaved flags from file properties before sending to API.
+     * The API doesn't expect the unsaved flag, but we need it for linking logic.
+     */
+    const stripUnsavedFlags = (data) => {
+        const result = { ...data };
+        const fileParameters = parameters.filter((param) => param.type === 'file');
+        fileParameters.forEach((param) => {
+            if (Array.isArray(result[param.id])) {
+                result[param.id] = result[param.id].map((file) => ({
+                    id: file.id,
+                    name: file.name,
+                }));
+            }
+        });
+        return result;
+    };
     const saveHandler = async (submission) => {
         if (!form) {
             return;
         }
-        submission = await formatSubmission(submission, apiServices, objectId, instanceId, form, setSnackbarError, undefined, parameters);
+        const formattedSubmission = await formatSubmission(submission, apiServices, objectId, instanceId, form, setSnackbarError, undefined, parameters);
+        submission = pick(formattedSubmission, parameters.map((parameter) => parameter.id));
         try {
             if (action?.type === 'create') {
-                const response = await apiServices.post(getPrefixedUrl(`/objects/${form.objectId}/instances/actions`), {
-                    actionId: form.actionId,
-                    input: omit(submission, sanitizedObject?.properties
-                        ?.filter((property) => property.formula || property.type === 'collection')
-                        .map((property) => property.id) ?? []),
-                });
-                if (response) {
-                    // Manually link files to created instance.
-                    await linkFiles(submission, { id: response.id, objectId: form.objectId });
-                    onSubmissionSuccess(response);
+                let response = undefined;
+                if ((await objectStore.get()).rootObjectId === 'sys__file' && actionId) {
+                    response = await handleFileUpload(apiServices, submission, actionId, objectId, instanceId, associatedObject && !('propertyId' in associatedObject) ? associatedObject : undefined);
+                }
+                else {
+                    response = await apiServices.post(getPrefixedUrl(`/objects/${objectId}/instances/actions`), {
+                        actionId: actionId,
+                        instanceId: instanceId,
+                        input: stripUnsavedFlags(submission),
+                    });
                 }
+                // Manually link files to created instance.
+                await linkFiles(submission, { id: response.id, objectId: form.objectId });
+                onSubmissionSuccess(response);
             }
             else if (instanceId && action) {
-                const response = await objectStore.instanceAction(instanceId, {
-                    actionId: action.id,
-                    input: omit(submission, sanitizedObject?.properties
-                        ?.filter((property) => property.formula || property.type === 'collection')
-                        .map((property) => property.id) ?? []),
-                });
+                let response = undefined;
+                if ((await objectStore.get()).rootObjectId === 'sys__file') {
+                    response = await handleFileUpload(apiServices, submission, action.id, objectId, instanceId);
+                }
+                else {
+                    response = await apiServices.post(getPrefixedUrl(`/objects/${objectId}/instances/${instanceId}/actions`), {
+                        actionId: action.id,
+                        input: stripUnsavedFlags(submission),
+                    });
+                }
                 if (sanitizedObject && instance) {
+                    if (!onAutosave) {
+                        // For non-autosave updates, link any uploaded files to the instance.
+                        await linkFiles(submission, { id: instanceId, objectId: objectId });
+                    }
                     onSubmissionSuccess(response);
-                    deleteDocuments(submission, true, apiServices, sanitizedObject, instance, action, setSnackbarError);
+                    // Only delete the necessary files after submission succeeds to avoid deleting a file prematurely.
+                    await deleteDocuments(submission, true, apiServices, sanitizedObject, instance, action, setSnackbarError);
                 }
             }
         }
         catch (error) {
-            // Handle deleteDocuments for uploaded documents if the main submission fails
-            if (instanceId && action && sanitizedObject && instance) {
-                deleteDocuments(submission, false, apiServices, sanitizedObject, instance, action, setSnackbarError);
-            }
             setSnackbarError({
                 isError: true,
                 showAlert: true,
                 message: error.response?.data?.error?.message ?? 'An error occurred',
             });
-            throw error; // Throw error so caller knows submission failed
-        }
-    };
-    const getDefaultValues = async (unnestedEntries, instanceData) => {
-        const result = {};
-        for (const entry of unnestedEntries) {
-            const fieldId = getEntryId(entry);
-            if (!fieldId)
-                continue;
-            const fieldValue = get(instanceData, fieldId);
-            if ((entry.type === 'input' || entry.type === 'inputField') &&
-                isAddressProperty(entry.parameterId || entry.input?.id)) {
-                if ((isEmpty(instanceData) || fieldValue === undefined || fieldValue === null || fieldValue === '') &&
-                    entry?.display?.defaultValue &&
-                    parameters) {
-                    const defaultValuesArray = await evalDefaultVals(parameters, unnestedEntries, entry, fieldValue, fieldId, apiServices, userAccount, instanceData);
-                    if (isArray(defaultValuesArray)) {
-                        defaultValuesArray.forEach(({ fieldId, fieldValue }) => {
-                            set(result, fieldId, fieldValue);
-                        });
-                    }
-                }
-                else if (fieldValue !== undefined && fieldValue !== null) {
-                    set(result, fieldId, fieldValue);
-                }
-            }
-            else if (entry.type !== 'sections' && entry.type !== 'columns' && entry.type !== 'content') {
-                const parameter = parameters?.find((param) => param.id === fieldId);
-                if (associatedObject?.propertyId === fieldId &&
-                    associatedObject?.instanceId &&
-                    parameter &&
-                    action?.type === 'create') {
-                    try {
-                        const instance = await apiServices.get(getPrefixedUrl(`/objects/${parameter.objectId}/instances/${associatedObject.instanceId}`));
-                        result[associatedObject.propertyId] = instance;
-                    }
-                    catch (error) {
-                        console.error(error);
-                    }
-                }
-                else if (entry.type !== 'readonlyField') {
-                    if (isEmptyWithDefault(fieldValue, entry, instanceData)) {
-                        if (fieldId && parameters && parameters.length > 0) {
-                            const defaultValuesArray = await evalDefaultVals(parameters, unnestedEntries, entry, fieldValue, fieldId, apiServices, userAccount, instanceData);
-                            for (const { fieldId, fieldValue } of defaultValuesArray) {
-                                const parameter = parameters?.find((param) => param.id === fieldId);
-                                if (parameter?.type === 'object') {
-                                    const dependentFields = await processValueUpdate(unnestedEntries, parameters, fieldValue, apiServices, fieldId, formDataRef.current, userAccount);
-                                    for (const field of dependentFields) {
-                                        set(result, field.fieldId, field.fieldValue);
-                                    }
-                                }
-                                set(result, fieldId, fieldValue);
-                            }
-                        }
-                    }
-                    else if (parameter?.type === 'boolean' && (fieldValue === undefined || fieldValue === null)) {
-                        result[fieldId] = false;
-                    }
-                    else if (fieldValue !== undefined && fieldValue !== null) {
-                        if (parameter?.type === 'richText' && typeof fieldValue === 'string') {
-                            let RTFFieldValue = fieldValue;
-                            if (!fieldValue.trim().startsWith('{\\rtf')) {
-                                RTFFieldValue = plainTextToRtf(fieldValue);
-                            }
-                            result[fieldId] = RTFFieldValue;
-                        }
-                        else {
-                            result[fieldId] = fieldValue;
-                        }
-                    }
-                }
+            if (instanceId && action && sanitizedObject && instance) {
+                // For an update, uploaded documents have been linked to the instance and need to be deleted.
+                await deleteDocuments(submission, false, apiServices, sanitizedObject, instance, action, setSnackbarError);
             }
+            throw error; // Throw error so caller knows submission failed
         }
-        return result;
     };
     const removeUneditedProtectedValues = (data) => {
         const protectedProperties = sanitizedObject?.properties?.filter((prop) => prop.protection?.maskChar);
@@ -362,11 +458,20 @@ function FormRendererContainerInner(props) {
             const submission = await formatSubmission(cleanedData, apiServices, objectId, instanceId, form, setSnackbarError, undefined, parameters);
             // Handle object instance autosave
             if (instanceId && action?.type === 'update') {
+                const pickedSubmission = pick(submission, sanitizedObject?.properties
+                    ?.filter((property) => !property.formula && property.type !== 'collection')
+                    .map((property) => property.id) ?? []);
                 await apiServices.post(getPrefixedUrl(`/objects/${objectId}/instances/${instanceId}/actions`), {
                     actionId: form.autosaveActionId,
-                    input: pick(submission, sanitizedObject?.properties
-                        ?.filter((property) => !property.formula && property.type !== 'collection')
-                        .map((property) => property.id) ?? []),
+                    input: stripUnsavedFlags(pickedSubmission),
+                });
+                if (sanitizedObject && instance) {
+                    // Only delete the necessary files after submission succeeds to avoid deleting a file prematurely.
+                    await deleteDocuments(submission, true, apiServices, sanitizedObject, instance, action, setSnackbarError);
+                }
+                // Invalidate the instance to fetch the latest version
+                queryClient.invalidateQueries({
+                    queryKey: [objectId, instanceId, 'instance'],
                 });
             }
             setLastSavedData(cloneDeep(formDataRef.current));
@@ -385,21 +490,19 @@ function FormRendererContainerInner(props) {
             !flattenFormEntries.some((e) => (e.type === 'input' && e.parameterId === id) || (e.type === 'inputField' && e.input.id === id));
         if (isReadOnlyField)
             return;
-        if (parameter) {
-            if (parameter.type === 'object' && parameters && parameters.length > 0) {
+        if (parameter?.type === 'string' && parameter.enum && value) {
+            // If a single select property has a sortBy option that isn't NONE the value gets spread and doesn't save properly,
+            // this will make it correctly save the value
+            value = value.value ? value.value : value;
+        }
+        if (!isEqual(value, get(formDataRef.current, id))) {
+            if (parameter?.type === 'object' && parameters && parameters.length > 0) {
                 // On change of a related object, update default values dependent on that object
                 const dependentFields = await processValueUpdate(flattenFormEntries, parameters, value, apiServices, id, formDataRef.current, userAccount);
                 for (const field of dependentFields) {
                     onChange(field.fieldId, field.fieldValue);
                 }
             }
-            else if (parameter.type === 'string' && parameter.enum && value) {
-                // If a single select property has a sortBy option that isn't NONE the value gets spread and doesn't save properly,
-                // this will make it correctly save the value
-                value = value.value ? value.value : value;
-            }
-        }
-        if (!isEqual(value, get(formDataRef.current, id))) {
             const newData = { ...formDataRef.current };
             set(newData, id, value);
             setFormData(newData);
@@ -429,7 +532,7 @@ function FormRendererContainerInner(props) {
             border: !isLoading ? '1px solid #dbe0e4' : undefined,
             ...sx,
         } }, !isLoading ? (React.createElement(React.Fragment, null,
-        React.createElement(FormRenderer, { onSubmit: onSubmit ? (data) => onSubmit(data, saveHandler) : saveHandler, onSubmitError: onSubmitError, onDiscardChanges: onDiscardChanges, richTextEditor: richTextEditor, hideTitle: title?.hidden, fieldHeight: display?.fieldHeight ?? 'medium', value: formDataRef.current, form: form, instance: instance, onChange: onChange, onAutosave: onAutosave, associatedObject: associatedObject, renderHeader: composedRenderHeader, renderBody: renderBody, renderFooter: renderFooter }))) : (React.createElement(Box, { sx: { padding: '20px' } },
+        React.createElement(FormRenderer, { onSubmit: onSubmit ? async (data) => await onSubmit(data, saveHandler) : saveHandler, onSubmitError: onSubmitError, onDiscardChanges: onDiscardChanges, richTextEditor: richTextEditor, hideTitle: title?.hidden, fieldHeight: display?.fieldHeight ?? 'medium', value: formDataRef.current, form: form, instance: instance, onChange: onChange, onAutosave: onAutosave, associatedObject: associatedObject && 'propertyId' in associatedObject ? associatedObject : undefined, renderHeader: composedRenderHeader, renderBody: renderBody, renderFooter: renderFooter }))) : (React.createElement(Box, { sx: { padding: '20px' } },
         React.createElement(Box, { display: 'flex', width: '100%', justifyContent: 'space-between' },
             React.createElement(Skeleton, { width: '78%', sx: { borderRadius: '8px', height: '40px' } }),
             React.createElement(Skeleton, { width: '20%', sx: { borderRadius: '8px', height: '40px' } })),

package/dist/published/components/custom/FormV2/components/DefaultValues.d.ts

@@ -1,6 +1,6 @@
 import { ApiServices, FormEntry, InputField, InputParameter, InputParameterReference, ObjectInstance, Reference, UserAccount } from '@evoke-platform/context';
 import { FieldValues } from 'react-hook-form';
-export declare function evalDefaultVals(parameters: InputParameter[], unnestedEntries: FormEntry[], entry: InputParameterReference | InputField, fieldValue: unknown, fieldId: string, apiServices: ApiServices, userAccount?: UserAccount, formValues?: FieldValues, updatedRelatedObjectValue?: ObjectInstance | null | Reference): Promise<{
+export declare function evalDefaultVals(parameters: InputParameter[], entry: InputParameterReference | InputField, fieldValue: unknown, fieldId: string, apiServices: ApiServices, userAccount?: UserAccount, formValues?: FieldValues, updatedRelatedObjectValue?: ObjectInstance | null | Reference, updatedRelatedObjectParamId?: string): Promise<{
     fieldId: string;
     fieldValue: unknown;
 }[]>;