@evoke-platform/ui-components 1.13.0-dev.5 → 1.13.0

package/dist/published/components/custom/CriteriaBuilder/PropertyTreeItem.d.ts

@@ -1,13 +1,14 @@
 import { TreeItemProps } from '@mui/x-tree-view';
 import React from 'react';
-import { TreeItem, TreeViewObject, TreeViewProperty } from './types';
+import { Obj } from '../../../types';
+import { TreeItem } from './types';
 type PropertyTreeItemProps = TreeItemProps & {
     items: TreeItem[];
     expanded: string[];
     setExpanded: (expanded: string[]) => void;
-    updateNodeChildren: (nodeId: string, children: TreeViewProperty[]) => void;
-    fetchObject: (id: string) => Promise<TreeViewObject | undefined>;
-    handleTreePropertySelect: (propertyId: string) => void;
+    updateNodeChildren: (nodeId: string, children: TreeItem[]) => void;
+    fetchObject: (id: string) => Promise<Obj | undefined>;
+    handleTreePropertySelect: (propertyId: string) => Promise<void>;
 };
 export declare const PropertyTreeItem: (props: PropertyTreeItemProps) => React.JSX.Element;
 export {};

package/dist/published/components/custom/CriteriaBuilder/PropertyTreeItem.js

@@ -11,47 +11,35 @@ export const PropertyTreeItem = (props) => {
             return;
         }
         const item = findTreeItemById(items, itemId);
-        if (item?.type === 'loadingFailed') {
-            e.stopPropagation();
-            return;
-        }
-        if (item?.children) {
+        if (item?.type === 'object') {
             e.stopPropagation();
             // If the item has an associated "objectId", fetch the properties of the object and expand the item.
-            if (item?.type === 'object' &&
-                item.objectId &&
-                item.children?.length === 1 &&
-                item.children[0].type === 'loading') {
-                try {
-                    const object = await fetchObject(item.objectId);
-                    if (object) {
-                        updateNodeChildren(itemId, object.properties
-                            .filter((prop) => prop.type !== 'collection')
-                            .map((prop) => ({
-                            ...prop,
-                            id: `${itemId}.${prop.id}`,
-                            children: prop.children?.map((child) => ({
-                                ...child,
-                                id: `${itemId}.${prop.id}.${child.id}`,
-                            })),
-                        })));
-                    }
-                }
-                catch (error) {
-                    updateNodeChildren(itemId, [
-                        {
-                            id: `${itemId}-failed`,
-                            name: 'Loading Failed',
-                            type: 'loadingFailed',
-                        },
-                    ]);
-                    console.error('Error fetching object:', error);
+            if (item.objectId && item.children?.length === 1 && item.children[0].type === 'loading') {
+                const object = item.objectId ? await fetchObject(item.objectId) : undefined;
+                if (object) {
+                    updateNodeChildren(itemId, (object.properties ?? []).map((prop) => ({
+                        id: `${itemId}.${prop.id}`,
+                        label: prop.name,
+                        value: `${itemId}.${prop.id}`,
+                        type: prop.type,
+                        objectId: prop.objectId,
+                        children: prop.type === 'object'
+                            ? [
+                                {
+                                    id: `${itemId}.${prop.id}-loading`,
+                                    label: 'Loading...',
+                                    value: `${itemId}.${prop.id}-loading`,
+                                    type: 'loading',
+                                },
+                            ]
+                            : undefined,
+                    })));
                 }
             }
             setExpanded([...expanded, itemId]);
             return;
         }
-        handleTreePropertySelect(itemId);
+        await handleTreePropertySelect(itemId);
     };
     return React.createElement(RichTreeItem, { itemId: itemId, label: label, children: children, onClick: onClick });
 };

package/dist/published/components/custom/CriteriaBuilder/types.d.ts

@@ -1,8 +1,17 @@
 /// <reference types="react" />
-import { Property } from '@evoke-platform/context';
 import { BaseSelectorProps } from 'react-querybuilder';
 import { ExpandedProperty } from '../../../types';
 import { AutocompleteOption, TreeViewBaseItem } from '../../core';
+export type ObjectProperty = {
+    id: string;
+    name: string;
+    type: string;
+    enum?: string[];
+    required?: boolean;
+    searchable?: boolean;
+    objectId?: string;
+    formula?: string;
+};
 export type CustomSelectorProps = BaseSelectorProps & {
     options: AutocompleteOption[] | any[];
     fieldData?: Record<string, any>;
@@ -19,7 +28,7 @@ export type PresetValue = {
     };
     type?: string;
 };
-export type TreeViewProperty = Property & {
+export type TreeViewProperty = ObjectProperty & {
     children?: TreeViewProperty[];
 };
 export type TreeViewObject = {

package/dist/published/components/custom/CriteriaBuilder/utils.d.ts

@@ -1,16 +1,43 @@
 import { Property } from '@evoke-platform/context';
 import { RuleGroupType } from 'react-querybuilder';
-import { TreeItem, TreeViewProperty } from './types';
+import { Obj, ObjectProperty } from '../../../types';
+import { TreeItem } from './types';
 /**
  * Recursively updates a node in a tree structure by applying an updater function to the node with the specified ID.
  *
- * @param {TreeViewProperty[]} tree - The tree structure to update.
+ * @param {TreeItem[]} tree - The tree structure to update.
  * @param {string} nodeId - The ID of the node to update.
- * @param {(node: TreeViewProperty) => TreeViewProperty} updater - The function to apply to the node.
- * @returns {TreeViewProperty[]} - The updated tree structure.
+ * @param {(node: TreeItem) => TreeItem} updater - The function to apply to the node.
+ * @returns {TreeItem[]} - The updated tree structure.
  */
-export declare const updateTreeViewProperty: (tree: TreeViewProperty[], nodeId: string, updater: (node: TreeViewProperty) => TreeViewProperty) => TreeViewProperty[];
-export declare const convertTreeViewPropertyToTreeItem: (property: TreeViewProperty) => TreeItem;
+export declare const updateTreeNode: (tree: TreeItem[], nodeId: string, updater: (node: TreeItem) => TreeItem) => TreeItem[];
+type FetchObjectFunction = (id: string) => Promise<Obj | undefined>;
+/**
+ * Fetches the display name path for a given property ID within an object hierarchy.
+ *
+ * @param {string} propertyId - The property ID to find the display name for.
+ * @param {Obj} rootObject - The root object to start the search from.
+ * @param {FetchObjectFunction} fetchObject - Function to fetch an object by its ID.
+ * @returns {Promise<string>} - A promise that resolves to the display name path.
+ */
+export declare const fetchDisplayNamePath: (propertyId: string, rootObject: Obj, fetchObject: FetchObjectFunction) => Promise<string>;
+/**
+ * stores full dot-notation path to each property ID in the given array of properties.
+ *
+ * @param {ObjectProperty[]} properties - The array of properties to update.
+ * @param {string} parentPath - The parent path to attach to each property ID.
+ * @returns {ObjectProperty[]} The updated array of properties with the parent path attached to each property ID.
+ */
+export declare const setIdPaths: (properties: ObjectProperty[], parentPath: string) => ObjectProperty[];
+/**
+ * Traverses a property path within an object hierarchy to retrieve detailed property information.
+ *
+ * @param {string} propertyPath - The dot-separated path of the property to traverse.
+ * @param {Obj} rootObject - The root object from which to start the traversal.
+ * @param {FetchObjectFunction} fetchObject - A function to fetch an object by its ID.
+ * @returns {Promise<ObjectProperty | null>} A promise that resolves to an ObjectProperty if found, or null otherwise.
+ */
+export declare const traversePropertyPath: (propertyPath: string, rootObject: Obj, fetchObject: (objectId: string) => Promise<Obj | undefined>) => Promise<ObjectProperty | null>;
 /**
  * Truncates the name path if it exceeds the specified character limit.
  *
@@ -41,3 +68,4 @@ export declare const ALL_OPERATORS: {
  */
 export declare const getReadableQuery: (mongoQuery?: Record<string, unknown>, properties?: Property[]) => string;
 export declare const findTreeItemById: (nodes: TreeItem[], nodeId: string) => TreeItem | null;
+export {};

package/dist/published/components/custom/CriteriaBuilder/utils.js

@@ -2,32 +2,105 @@ import { isArray, isEmpty, startCase } from 'lodash';
 /**
  * Recursively updates a node in a tree structure by applying an updater function to the node with the specified ID.
  *
- * @param {TreeViewProperty[]} tree - The tree structure to update.
+ * @param {TreeItem[]} tree - The tree structure to update.
  * @param {string} nodeId - The ID of the node to update.
- * @param {(node: TreeViewProperty) => TreeViewProperty} updater - The function to apply to the node.
- * @returns {TreeViewProperty[]} - The updated tree structure.
+ * @param {(node: TreeItem) => TreeItem} updater - The function to apply to the node.
+ * @returns {TreeItem[]} - The updated tree structure.
  */
-export const updateTreeViewProperty = (tree, nodeId, updater) => {
+export const updateTreeNode = (tree, nodeId, updater) => {
     return tree.map((node) => {
         if (node.id === nodeId) {
             return updater(node);
         }
         else if (node.children) {
-            return { ...node, children: updateTreeViewProperty(node.children, nodeId, updater) };
+            return { ...node, children: updateTreeNode(node.children, nodeId, updater) };
         }
         else {
             return node;
         }
     });
 };
-export const convertTreeViewPropertyToTreeItem = (property) => ({
-    id: property.id,
-    label: property.name,
-    value: property.id,
-    type: property.type,
-    objectId: property.objectId,
-    children: property.children?.map(convertTreeViewPropertyToTreeItem),
-});
+/**
+ * Fetches the display name path for a given property ID within an object hierarchy.
+ *
+ * @param {string} propertyId - The property ID to find the display name for.
+ * @param {Obj} rootObject - The root object to start the search from.
+ * @param {FetchObjectFunction} fetchObject - Function to fetch an object by its ID.
+ * @returns {Promise<string>} - A promise that resolves to the display name path.
+ */
+export const fetchDisplayNamePath = async (propertyId, rootObject, fetchObject) => {
+    const propertyInfo = await traversePropertyPath(propertyId, rootObject, fetchObject);
+    return propertyInfo ? propertyInfo.name : '';
+};
+/**
+ * stores full dot-notation path to each property ID in the given array of properties.
+ *
+ * @param {ObjectProperty[]} properties - The array of properties to update.
+ * @param {string} parentPath - The parent path to attach to each property ID.
+ * @returns {ObjectProperty[]} The updated array of properties with the parent path attached to each property ID.
+ */
+export const setIdPaths = (properties, parentPath) => {
+    return properties.map((prop) => {
+        const fullPath = parentPath ? `${parentPath}.${prop.id}` : prop.id;
+        return {
+            ...prop,
+            id: fullPath,
+        };
+    });
+};
+/**
+ * Traverses a property path within an object hierarchy to retrieve detailed property information.
+ *
+ * @param {string} propertyPath - The dot-separated path of the property to traverse.
+ * @param {Obj} rootObject - The root object from which to start the traversal.
+ * @param {FetchObjectFunction} fetchObject - A function to fetch an object by its ID.
+ * @returns {Promise<ObjectProperty | null>} A promise that resolves to an ObjectProperty if found, or null otherwise.
+ */
+export const traversePropertyPath = async (propertyPath, rootObject, fetchObject) => {
+    const segments = propertyPath.split('.');
+    let currentObject = rootObject;
+    let fullPath = '';
+    let namePath = '';
+    for (let i = 0; i < segments.length; i++) {
+        const remainingPath = segments.slice(i).join('.');
+        let prop = currentObject.properties?.find((p) => p.id === remainingPath);
+        if (prop) {
+            // flattened address or user properties
+            fullPath = fullPath ? `${fullPath}.${remainingPath}` : remainingPath;
+            namePath = namePath ? `${namePath} / ${prop.name}` : prop.name;
+            return {
+                ...prop,
+                id: fullPath,
+                name: namePath,
+            };
+        }
+        else {
+            prop = currentObject.properties?.find((p) => p.id === segments[i]);
+            if (!prop) {
+                return null;
+            }
+            fullPath = fullPath ? `${fullPath}.${prop.id}` : prop.id;
+            namePath = namePath ? `${namePath} / ${prop.name}` : prop.name;
+            if (i === segments.length - 1) {
+                return {
+                    ...prop,
+                    id: fullPath,
+                    name: namePath,
+                };
+            }
+            if (prop.type === 'object' && prop.objectId) {
+                const fetchedObject = await fetchObject(prop.objectId);
+                if (fetchedObject) {
+                    currentObject = fetchedObject;
+                }
+                else {
+                    return null;
+                }
+            }
+        }
+    }
+    return null;
+};
 /**
  * Truncates the name path if it exceeds the specified character limit.
  *
@@ -270,11 +343,9 @@ export const findTreeItemById = (nodes, nodeId) => {
     for (const node of nodes) {
         if (node.id === nodeId)
             return node;
-        if (nodeId.startsWith(node.id)) {
-            const found = node.children && findTreeItemById(node.children, nodeId);
-            if (found)
-                return found;
-        }
+        const found = node.children && findTreeItemById(node.children, nodeId);
+        if (found)
+            return found;
     }
     return null;
 };

package/dist/published/components/custom/Form/FormComponents/RepeatableFieldComponent/RepeatableField.js

@@ -402,7 +402,7 @@ const RepeatableField = (props) => {
                 React.createElement(Table, { stickyHeader: true, sx: { minWidth: 650 } },
                     React.createElement(TableHead, { sx: { backgroundColor: '#F4F6F8' } },
                         React.createElement(TableRow, null,
-                            columns?.map((prop) => React.createElement(TableCell, { sx: styles.tableCell }, prop.name)),
+                            columns?.map((prop) => (React.createElement(TableCell, { sx: styles.tableCell }, prop.name))),
                             canUpdateProperty && React.createElement(TableCell, { sx: { ...styles.tableCell, width: '80px' } }))),
                     React.createElement(TableBody, null, relatedInstances?.map((relatedInstance, index) => (React.createElement(TableRow, { key: relatedInstance.id },
                         columns?.map((prop) => {

package/dist/published/components/custom/Form/utils.d.ts

@@ -25,7 +25,6 @@ export declare function flattenFormComponents(components?: ActionInput[]): Actio
 export declare function addObjectPropertiesToComponentProps(properties: Property[], formComponents: any[], allCriteriaInputs?: string[], instance?: ObjectInstance, objectPropertyInputProps?: ObjectPropertyInputProps, associatedObject?: {
     instanceId?: string;
     propertyId?: string;
-    objectId?: string;
 }, autoSave?: (data: Record<string, unknown>) => void, readOnly?: boolean, defaultPages?: Record<string, string>, navigateTo?: (path: string) => void, queryAddresses?: (query: string) => Promise<Address[]>, apiServices?: ApiServices, isModal?: boolean, fieldHeight?: 'small' | 'medium', richTextEditor?: typeof ReactComponent): Promise<ActionInput[]>;
 export declare function getDefaultValue(initialValue: unknown, selectOptions?: AutocompleteOption[]): unknown;
 export declare const buildComponentPropsFromObjectProperties: (properties: Property[], objectId: string, instance?: ObjectInstance, objectPropertyInputProps?: ObjectPropertyInputProps, hasActionPermissions?: boolean, autoSave?: ((data: Record<string, unknown>) => void) | undefined, readOnly?: boolean, queryAddresses?: ((query: string) => Promise<Address[]>) | undefined, isModal?: boolean, fieldHeight?: 'small' | 'medium', richTextEditor?: typeof ReactComponent) => unknown[];

package/dist/published/components/custom/FormField/DateTimePickerSelect/DateTimePickerSelect.js

@@ -5,8 +5,7 @@ import { useFormContext } from '../../../../theme/hooks';
 import { InvalidDate } from '../../../../util';
 import { DateTimePicker, LocalizationProvider, TextField } from '../../../core';
 import InputFieldComponent from '../InputFieldComponent/InputFieldComponent';
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const { format } = require('small-date');
+import { format } from 'small-date';
 function asCalendarDate(value) {
     if (!value) {
         return null;

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

@@ -12,6 +12,7 @@ export type FormRendererProps = BaseProps & {
     onSubmit?: (data: FieldValues) => void;
     onDiscardChanges?: () => void;
     onSubmitError?: SubmitErrorHandler<FieldValues>;
+    hideTitle?: boolean;
     fieldHeight?: 'small' | 'medium';
     form: EvokeForm;
     title?: string | React.ReactNode;
@@ -21,7 +22,6 @@ export type FormRendererProps = BaseProps & {
     associatedObject?: {
         instanceId: string;
         propertyId: string;
-        objectId?: string;
     };
     renderHeader?: (props: HeaderProps) => React.ReactNode;
     renderBody?: (props: BodyProps) => React.ReactNode;

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

@@ -12,7 +12,7 @@ import { assignIdsToSectionsAndRichText, convertPropertiesToParams, entryIsVisib
 import { handleValidation } from './components/ValidationFiles/Validation';
 import ValidationErrors from './components/ValidationFiles/ValidationErrors';
 const FormRendererInternal = (props) => {
-    const { onSubmit, onDiscardChanges, onSubmitError: onSubmitErrorOverride, value, fieldHeight, richTextEditor, form, instance, onChange, onAutosave, associatedObject, renderHeader, renderBody, renderFooter, } = props;
+    const { onSubmit, onDiscardChanges, onSubmitError: onSubmitErrorOverride, value, hideTitle = false, fieldHeight, richTextEditor, form, instance, onChange, onAutosave, associatedObject, renderHeader, renderBody, renderFooter, } = props;
     const { entries, name: title, objectId, actionId, display } = form;
     const { register, unregister, setValue, reset, handleSubmit, formState: { errors, isSubmitted }, getValues, } = useForm({
         defaultValues: value,
@@ -177,6 +177,7 @@ const FormRendererInternal = (props) => {
         }, (errors) => onSubmitError(errors))();
     }
     const headerProps = {
+        hideTitle,
         title,
         onExpandAll: handleExpandAll,
         onCollapseAll: handleCollapseAll,

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

@@ -19,6 +19,9 @@ export type FormRendererContainerProps = BaseProps & {
     defaultPages?: Record<string, string>;
     pageNavigation?: string;
     dataType?: 'objectInstances';
+    title?: {
+        hidden?: boolean;
+    };
     display?: {
         fieldHeight?: 'small' | 'medium';
     };
@@ -31,7 +34,6 @@ export type FormRendererContainerProps = BaseProps & {
     associatedObject?: {
         instanceId: string;
         propertyId: string;
-        objectId?: string;
     };
     renderContainer?: (state: FormRendererState) => React.ReactNode;
     renderHeader?: FormRendererProps['renderHeader'];

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

@@ -10,7 +10,7 @@ import Header from './components/Header';
 import { convertPropertiesToParams, createFileLinks, deleteDocuments, encodePageSlug, formatSubmission, getEntryId, getPrefixedUrl, getUnnestedEntries, isAddressProperty, isEmptyWithDefault, plainTextToRtf, } from './components/utils';
 import FormRenderer from './FormRenderer';
 function FormRendererContainer(props) {
-    const { instanceId, pageNavigation, dataType, display, formId, objectId, actionId, richTextEditor, onSubmit, onDiscardChanges: onDiscardChangesOverride, associatedObject, renderContainer, onSubmitError, sx, renderHeader, renderBody, renderFooter, } = props;
+    const { instanceId, pageNavigation, dataType, title, display, formId, objectId, actionId, richTextEditor, onSubmit, onDiscardChanges: onDiscardChangesOverride, associatedObject, renderContainer, onSubmitError, sx, renderHeader, renderBody, renderFooter, } = props;
     const apiServices = useApiServices();
     const navigateTo = useNavigate();
     const { id: appId } = useApp();
@@ -255,10 +255,10 @@ function FormRendererContainer(props) {
                 const parameter = parameters?.find((param) => param.id === fieldId);
                 if (associatedObject?.propertyId === fieldId &&
                     associatedObject?.instanceId &&
-                    (parameter || associatedObject.objectId) &&
+                    parameter &&
                     action?.type === 'create') {
                     try {
-                        const instance = await apiServices.get(getPrefixedUrl(`/objects/${parameter?.objectId || associatedObject.objectId}/instances/${associatedObject.instanceId}`));
+                        const instance = await apiServices.get(getPrefixedUrl(`/objects/${parameter.objectId}/instances/${associatedObject.instanceId}`));
                         result[associatedObject.propertyId] = instance;
                     }
                     catch (error) {
@@ -327,7 +327,7 @@ function FormRendererContainer(props) {
         try {
             setIsSaving(true);
             const cleanedData = removeUneditedProtectedValues(formDataRef.current);
-            const submission = await formatSubmission(cleanedData, apiServices, objectId, instanceId, form, setSnackbarError);
+            const submission = await formatSubmission(cleanedData, apiServices, objectId, instanceId, form, setSnackbarError, undefined, parameters);
             // Handle object instance autosave
             if (instanceId && action?.type === 'update') {
                 await apiServices.post(getPrefixedUrl(`/objects/${objectId}/instances/${instanceId}/actions`), {
@@ -398,7 +398,7 @@ function FormRendererContainer(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, 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 ? (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(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/Body.js

@@ -22,6 +22,6 @@ export const Body = (props) => {
             React.createElement(Skeleton, { width: '32%', sx: { borderRadius: '8px', height: '40px' } })),
         React.createElement(Box, { display: 'flex', width: '100%', justifyContent: 'space-between' },
             React.createElement(Skeleton, { width: '49%', sx: { borderRadius: '8px', height: '40px' } }),
-            React.createElement(Skeleton, { width: '49%', sx: { borderRadius: '8px', height: '40px' } })))) : (React.createElement(Box, { sx: { paddingX: isSm || isXs ? 2 : 3, ...sx } }, entries.map((entry, index) => (React.createElement(RecursiveEntryRenderer, { key: index, entry: entry })))))));
+            React.createElement(Skeleton, { width: '49%', sx: { borderRadius: '8px', height: '40px' } })))) : (React.createElement(Box, { sx: { paddingX: isSm || isXs ? 2 : 3, paddingY: isSm || isXs ? '6px' : '14px', ...sx } }, entries.map((entry, index) => (React.createElement(RecursiveEntryRenderer, { key: index, entry: entry })))))));
 };
 export default Body;

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

@@ -20,7 +20,7 @@ export const Footer = (props) => {
             padding: isSmallerThanMd ? '16px' : '20px',
             justifyContent: isXs ? 'center' : 'flex-end',
             alignItems: 'center',
-            borderTop: '1px solid #f4f6f8',
+            borderTop: '1px solid #e9ecef',
             borderRadius: '0px 0px 6px 6px',
             zIndex: 3,
             width: '100%',

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

@@ -23,7 +23,6 @@ type FormContextType = {
     associatedObject?: {
         instanceId: string;
         propertyId: string;
-        objectId?: string;
     };
     form?: EvokeForm;
     width: number;

package/dist/published/components/custom/FormV2/components/FormFieldTypes/CollectionFiles/ActionDialog.d.ts

@@ -13,7 +13,6 @@ export type ActionDialogProps = {
     associatedObject?: {
         instanceId: string;
         propertyId: string;
-        objectId?: string;
     };
 };
 export declare const ActionDialog: (props: ActionDialogProps) => React.JSX.Element;

package/dist/published/components/custom/FormV2/components/FormFieldTypes/CollectionFiles/RepeatableField.js

@@ -9,7 +9,7 @@ import { Accordion, AccordionDetails, AccordionSummary, Button, IconButton, Skel
 import { Box } from '../../../../../layout';
 import { getReadableQuery } from '../../../../CriteriaBuilder';
 import { retrieveCustomErrorMessage } from '../../../../Form/utils';
-import { convertPropertiesToParams, deleteDocuments, formatSubmission, getPrefixedUrl, transformToWhere, } from '../../utils';
+import { deleteDocuments, formatSubmission, getPrefixedUrl, transformToWhere } from '../../utils';
 import { ActionDialog } from './ActionDialog';
 import { DocumentViewerCell } from './DocumentViewerCell';
 const styles = {
@@ -344,7 +344,7 @@ const RepeatableField = (props) => {
         // when save is called we know that fieldDefinition is a parameter and fieldDefinition.objectId is defined
         input = await formatSubmission(input, apiServices, fieldDefinition.objectId, selectedInstanceId, action?.type === 'update' ? updateForm : undefined, undefined, instance?.id && fieldDefinition.relatedPropertyId
             ? { instanceId: instance.id, propertyId: fieldDefinition.relatedPropertyId }
-            : undefined, action?.parameters ?? (relatedObject && convertPropertiesToParams(relatedObject)));
+            : undefined);
         if (action?.type === 'create' && entry.display?.createActionId) {
             const updatedInput = {
                 ...input,
@@ -529,7 +529,7 @@ const RepeatableField = (props) => {
                 React.createElement(Table, { stickyHeader: true, sx: { minWidth: 650 } },
                     React.createElement(TableHead, { sx: { backgroundColor: '#F4F6F8' } },
                         React.createElement(TableRow, null,
-                            columns?.map((prop) => React.createElement(TableCell, { sx: styles.tableCell }, prop.name)),
+                            columns?.map((prop) => (React.createElement(TableCell, { sx: styles.tableCell }, prop.name))),
                             canUpdateProperty && React.createElement(TableCell, { sx: { ...styles.tableCell, width: '80px' } }))),
                     React.createElement(TableBody, null, relatedInstances?.map((relatedInstance, index) => (React.createElement(TableRow, { key: relatedInstance.id },
                         columns?.map((prop) => {

package/dist/published/components/custom/FormV2/components/FormFieldTypes/relatedObjectFiles/InstanceLookup.js

@@ -16,7 +16,7 @@ const SearchField = (props) => {
     };
     const handleSearch = async (e) => {
         const searchProperties = searchableColumns.map((column) => {
-            const columnId = column.id;
+            const columnId = column.type === 'object' ? `${column.id}.name` : column.id;
             return {
                 [columnId]: {
                     like: e.target.value,

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

@@ -126,7 +126,6 @@ function FormSections(props) {
                             display: 'flex',
                             flexDirection: 'column',
                             justifyContent: section.entries && section?.entries.length > 0 ? 'space-between' : 'flex-end',
-                            height: '100%',
                         } },
                         React.createElement(Box, null, section.entries &&
                             section.entries.map((sectionEntry, index) => {

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

@@ -7,6 +7,7 @@ export type HeaderProps = {
     hasAccordions: boolean;
     shouldShowValidationErrors?: boolean;
     validationContainerRef?: React.Ref<HTMLDivElement>;
+    hideTitle: boolean;
     title?: string;
     expandedSections?: ExpandedSection[];
     onExpandAll?: () => void;

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

@@ -7,7 +7,7 @@ import { Typography } from '../../../core/Typography';
 import Box from '../../../layout/Box/Box';
 import ValidationErrors from './ValidationFiles/ValidationErrors';
 const Header = (props) => {
-    const { title, errors, hasAccordions, shouldShowValidationErrors, validationContainerRef, sx, autosaveEnabled } = props;
+    const { title, errors, hasAccordions, shouldShowValidationErrors, validationContainerRef, sx, autosaveEnabled, hideTitle, autosaving, } = props;
     const { width } = useFormContext();
     const { breakpoints, isBelow } = useWidgetSize({
         scroll: false,
@@ -17,23 +17,32 @@ const Header = (props) => {
     const { isXs, isSm } = breakpoints;
     const isSmall = isSm || isXs;
     const displayValidationErrors = shouldShowValidationErrors && !isEmpty(errors);
+    if (hideTitle && !autosaveEnabled && !hasAccordions && !displayValidationErrors) {
+        return null;
+    }
     return (React.createElement(Box, { sx: {
             paddingX: isSmallerThanMd ? 2 : 3,
             paddingTop: '0px',
             display: 'flex',
             alignItems: 'center',
+            justifyContent: 'flex-end',
             flexWrap: 'wrap',
             paddingY: isSm || isXs ? 2 : 3,
             borderBottom: '1px solid #e9ecef',
             gap: isSm || isXs ? 2 : 3,
+            minHeight: '24px',
             ...sx,
         }, ref: validationContainerRef },
-        title && (React.createElement(Box, { sx: { flex: '1 1 auto', minWidth: 0, display: 'flex', alignItems: 'center', gap: 1 } },
-            React.createElement(Title, { ...props }),
-            props.autosaving && !isSmall && React.createElement(SavingIndicator, null))),
-        hasAccordions && (React.createElement(Box, { sx: { flex: '0 0 auto', display: 'flex', alignItems: 'center' } },
-            React.createElement(Box, { sx: { display: 'flex', alignItems: 'center' } },
-                React.createElement(AccordionActions, { ...props })),
+        ((!hideTitle && title) || (autosaving && !isSmall)) && (React.createElement(Box, { sx: {
+                flex: '1 1 auto',
+                minWidth: 0,
+                display: 'flex',
+                alignItems: 'center',
+                gap: 1,
+            } },
+            !hideTitle && title && React.createElement(Title, { ...props }),
+            autosaving && !isSmall ? React.createElement(SavingIndicator, null) : React.createElement(React.Fragment, null))),
+        hasAccordions && (React.createElement(Box, { sx: { flex: '0 0 auto', display: 'flex', alignItems: 'center', justifyContent: 'space-between' } },
             autosaveEnabled && (React.createElement(Box, { sx: {
                     width: '96px',
                     minWidth: '72px',
@@ -41,7 +50,9 @@ const Header = (props) => {
                     justifyContent: 'flex-end',
                     alignItems: 'center',
                     marginLeft: 0.5,
-                } }, props.autosaving && isSmall ? React.createElement(SavingIndicator, null) : React.createElement(Box, { sx: { width: '100%' } }))))),
+                } }, autosaving && isSmall ? React.createElement(SavingIndicator, null) : React.createElement(React.Fragment, null))),
+            React.createElement(Box, { sx: { display: 'flex', alignItems: 'center', justifyContent: 'center' } },
+                React.createElement(AccordionActions, { ...props })))),
         displayValidationErrors ? React.createElement(ValidationErrors, { errors: errors }) : null));
 };
 // Default slot components for convenience

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

@@ -0,0 +1,9 @@
+import React from 'react';
+import 'quill/dist/quill.snow.css';
+import 'quill-table-up/index.css';
+type EditorProps = {
+    /** HTML content to display in the read-only editor */
+    value: string;
+};
+declare const HtmlView: ({ value }: EditorProps) => React.JSX.Element;
+export default HtmlView;