@evoke-platform/ui-components 1.6.0-dev.20 → 1.6.0-dev.22

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

@@ -1,10 +1,11 @@
+import { Property } from '@evoke-platform/context';
 import React from 'react';
 import 'react-querybuilder/dist/query-builder.css';
 import { EvokeObject } from '../../../types';
-import { ObjectProperty, Operator, PresetValue, TreeViewObject } from './types';
+import { Operator, PresetValue, TreeViewObject } from './types';
 import { ValueEditorProps } from './ValueEditor';
 export type CriteriaInputProps = {
-    properties: ObjectProperty[];
+    properties: Property[];
     setCriteria: (criteria?: Record<string, unknown> | undefined) => void;
     criteria?: Record<string, unknown>;
     originalCriteria?: Record<string, unknown>;

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

@@ -186,7 +186,7 @@ const customSelector = (props) => {
                 return opts.find((o) => option === o.name)?.label || option;
             }
             return option.label;
-        }, isOptionEqualToValue: (option, value) => {
+        }, getOptionKey: (option) => option.name, isOptionEqualToValue: (option, value) => {
             if (typeof option === 'string') {
                 return option === value;
             }

package/dist/published/components/custom/FormField/AddressFieldComponent/AddressFieldComponent.test.js

@@ -8,7 +8,7 @@ import AddressFieldComponent from './addressFieldComponent';
 const addressProperty = {
     id: 'addressLine1',
     name: 'Line 1',
-    type: 'text',
+    type: 'string',
 };
 it('displays matching addresses', async () => {
     const user = userEvent.setup();

package/dist/published/components/custom/FormField/FormField.d.ts

@@ -1,11 +1,10 @@
-import { SelectOption } from '@evoke-platform/context';
+import { Property, SelectOption } from '@evoke-platform/context';
 import React, { FocusEventHandler, ReactNode } from 'react';
-import { ObjectProperty } from '../../../types';
 import { AutocompleteOption } from '../../core';
 import { Address } from './AddressFieldComponent/addressFieldComponent';
 export type FormFieldProps = {
     id?: string;
-    property: ObjectProperty;
+    property: Property;
     onChange?: Function;
     onBlur?: FocusEventHandler<HTMLInputElement | HTMLTextAreaElement>;
     defaultValue?: unknown;

package/dist/published/components/custom/FormField/Select/Select.test.js

@@ -11,23 +11,28 @@ describe('Single select', () => {
     const choiceProperty = {
         id: 'selectOptions',
         name: 'Select Options',
-        type: 'choices',
+        type: 'string',
     };
     it('returns selected option', async () => {
         const onChangeMock = vi.fn((name, value, property) => { });
         const user = userEvent.setup();
         const options = ['option 1', 'option 2', 'option 3'];
-        render(React.createElement(Select, { id: "testSelect", property: choiceProperty, selectOptions: options, onChange: onChangeMock }));
+        render(React.createElement(Select, { id: "testSelect", property: { ...choiceProperty, enum: options }, selectOptions: options, onChange: onChangeMock }));
         const input = screen.getByRole('combobox');
         await user.click(input);
         const option2 = await screen.findByRole('option', { name: 'option 2' });
         await user.click(option2);
-        expect(onChangeMock).toBeCalledWith('selectOptions', expect.objectContaining({ label: 'option 2', value: 'option 2' }), choiceProperty);
+        expect(onChangeMock).toBeCalledWith('selectOptions', expect.objectContaining({ label: 'option 2', value: 'option 2' }), {
+            id: 'selectOptions',
+            name: 'Select Options',
+            type: 'string',
+            enum: ['option 1', 'option 2', 'option 3'],
+        });
     });
     it('displays matching options', async () => {
         const user = userEvent.setup();
         const options = ['option 1', 'option 2', 'something different'];
-        render(React.createElement(Select, { id: "testSelect", property: choiceProperty, selectOptions: options, onChange: () => { } }));
+        render(React.createElement(Select, { id: "testSelect", property: { ...choiceProperty, enum: options }, selectOptions: options, onChange: () => { } }));
         const input = screen.getByRole('combobox');
         await user.type(input, 'option');
         await screen.findByRole('option', { name: 'option 1' });
@@ -40,7 +45,7 @@ describe('Single select', () => {
         { sortBy: 'DESC', expectedValues: ['option 3', 'option 2', 'option 1'] },
     ])('shows options in $sortBy order as dropdown display', async ({ sortBy, expectedValues }) => {
         const options = ['option 2', 'option 1', 'option 3'];
-        render(React.createElement(Select, { id: "testSelect", property: choiceProperty, selectOptions: options, displayOption: 'dropdown', sortBy: sortBy, onChange: vi.fn() }));
+        render(React.createElement(Select, { id: "testSelect", property: { ...choiceProperty, enum: options }, selectOptions: options, displayOption: 'dropdown', sortBy: sortBy, onChange: vi.fn() }));
         const user = userEvent.setup();
         const input = screen.getByRole('combobox');
         await user.click(input);
@@ -52,7 +57,7 @@ describe('Single select', () => {
         const onChangeMock = vi.fn((name, value, property) => { });
         const user = userEvent.setup();
         const options = ['option 1', 'option 2', 'option 3'];
-        render(React.createElement(Select, { id: "testSelect", property: choiceProperty, selectOptions: options, onChange: onChangeMock, isCombobox: true }));
+        render(React.createElement(Select, { id: "testSelect", property: { ...choiceProperty, enum: options }, selectOptions: options, onChange: onChangeMock, isCombobox: true }));
         const input = screen.getByRole('combobox');
         await user.click(input);
         // Verify the instruction text for a combobox displays as the sub-header of the combobox.
@@ -61,7 +66,12 @@ describe('Single select', () => {
         // Verify the option to add the custom value is displayed as an available option in the dropdown.
         const customOption = await screen.findByRole('option', { name: 'Add "custom option"' });
         await user.click(customOption);
-        expect(onChangeMock).toBeCalledWith('selectOptions', expect.objectContaining({ label: 'Add "custom option"', value: 'custom option' }), choiceProperty);
+        expect(onChangeMock).toBeCalledWith('selectOptions', expect.objectContaining({ label: 'Add "custom option"', value: 'custom option' }), {
+            id: 'selectOptions',
+            name: 'Select Options',
+            type: 'string',
+            enum: ['option 1', 'option 2', 'option 3'],
+        });
     });
 });
 describe('Multi select', () => {
@@ -76,7 +86,7 @@ describe('Multi select', () => {
         const user = userEvent.setup();
         const onChangeMock = vi.fn((name, value, property) => { });
         const options = ['option 1', 'option 2', 'option 3'];
-        render(React.createElement(Select, { id: "testSelect", property: multiChoiceProperty, selectOptions: options, onChange: onChangeMock }));
+        render(React.createElement(Select, { id: "testSelect", property: { ...multiChoiceProperty, enum: options }, selectOptions: options, onChange: onChangeMock }));
         const input = screen.getByRole('combobox');
         await user.click(input);
         const option2 = await screen.findByRole('option', { name: 'option 2' });
@@ -86,13 +96,18 @@ describe('Multi select', () => {
         const option3 = await screen.findByRole('option', { name: 'option 3' });
         await user.click(option3);
         expect(onChangeMock).toBeCalledTimes(2);
-        expect(onChangeMock).lastCalledWith('multiSelect', ['option 2', 'option 3'], multiChoiceProperty);
+        expect(onChangeMock).lastCalledWith('multiSelect', ['option 2', 'option 3'], {
+            id: 'multiSelect',
+            name: 'Select Multiple',
+            type: 'array',
+            enum: ['option 1', 'option 2', 'option 3'],
+        });
     });
     it('allows the user to enter custom values if it is combobox component', async () => {
         const onChangeMock = vi.fn((name, value, property) => { });
         const user = userEvent.setup();
         const options = ['option 1', 'option 2', 'option 3'];
-        render(React.createElement(Select, { id: "multiSelect", property: multiChoiceProperty, selectOptions: options, onChange: onChangeMock, isCombobox: true }));
+        render(React.createElement(Select, { id: "multiSelect", property: { ...multiChoiceProperty, enum: options }, selectOptions: options, onChange: onChangeMock, isCombobox: true }));
         const input = screen.getByRole('combobox');
         await user.click(input);
         // Verify the instruction text for a combobox displays as the sub-header of the combobox.
@@ -104,13 +119,18 @@ describe('Multi select', () => {
         const customOption2 = await screen.findByRole('option', { name: 'Add "custom option 2"' });
         await user.click(customOption2);
         expect(onChangeMock).toBeCalledTimes(2);
-        expect(onChangeMock).lastCalledWith('multiSelect', ['custom option 1', 'custom option 2'], multiChoiceProperty);
+        expect(onChangeMock).lastCalledWith('multiSelect', ['custom option 1', 'custom option 2'], {
+            id: 'multiSelect',
+            name: 'Select Multiple',
+            type: 'array',
+            enum: ['option 1', 'option 2', 'option 3'],
+        });
     });
     it('allows the user to enter custom values in conjunction with the predefined options if it is combobox component', async () => {
         const onChangeMock = vi.fn((name, value, property) => { });
         const user = userEvent.setup();
         const options = ['option 1', 'option 2', 'option 3'];
-        render(React.createElement(Select, { id: "multiSelect", property: multiChoiceProperty, selectOptions: options, onChange: onChangeMock, isCombobox: true }));
+        render(React.createElement(Select, { id: "multiSelect", property: { ...multiChoiceProperty, enum: options }, selectOptions: options, onChange: onChangeMock, isCombobox: true }));
         const input = screen.getByRole('combobox');
         await user.click(input);
         // Verify the instruction text for a combobox displays as the sub-header of the combobox.
@@ -122,14 +142,19 @@ describe('Multi select', () => {
         const option1 = await screen.findByRole('option', { name: 'option 1' });
         await user.click(option1);
         expect(onChangeMock).toBeCalledTimes(2);
-        expect(onChangeMock).lastCalledWith('multiSelect', ['custom option 1', 'option 1'], multiChoiceProperty);
+        expect(onChangeMock).lastCalledWith('multiSelect', ['custom option 1', 'option 1'], {
+            id: 'multiSelect',
+            name: 'Select Multiple',
+            type: 'array',
+            enum: ['option 1', 'option 2', 'option 3'],
+        });
     });
 });
 describe('Radio Single select', () => {
     const choiceProperty = {
         id: 'selectOptions',
         name: 'Select Options',
-        type: 'choices',
+        type: 'string',
     };
     it('returns selected radio option', async () => {
         const user = userEvent.setup();
@@ -146,7 +171,7 @@ describe('Radio Single select', () => {
         { sortBy: 'DESC', expectedValues: ['option 3', 'option 2', 'option 1'] },
     ])('shows options in $sortBy order as radio display', async ({ sortBy, expectedValues }) => {
         const options = ['option 2', 'option 1', 'option 3'];
-        render(React.createElement(Select, { id: "testSelect", property: choiceProperty, selectOptions: options, displayOption: 'radioButton', sortBy: sortBy, onChange: vi.fn() }));
+        render(React.createElement(Select, { id: "testSelect", property: { ...choiceProperty, enum: options }, selectOptions: options, displayOption: 'radioButton', sortBy: sortBy, onChange: vi.fn() }));
         const radioButtons = screen.getAllByRole('radio');
         const radioValues = radioButtons.map((radioButton) => radioButton.value);
         expect(radioValues).toEqual(expectedValues);
@@ -154,7 +179,7 @@ describe('Radio Single select', () => {
     it('renders an "Other" option in the radio group if the component is configured to support a custom value', async () => {
         const onChangeMock = vi.fn((name, value, property) => { });
         const options = ['option 1', 'option 2', 'option 3'];
-        render(React.createElement(Select, { id: "testSelect", property: choiceProperty, selectOptions: options, displayOption: 'radioButton', sortBy: 'ASC', onChange: onChangeMock, isCombobox: true }));
+        render(React.createElement(Select, { id: "testSelect", property: { ...choiceProperty, enum: options }, selectOptions: options, displayOption: 'radioButton', sortBy: 'ASC', onChange: onChangeMock, isCombobox: true }));
         await screen.findByRole('radio', { name: 'Other' });
     });
     it('renders a text field for a custom option if the "Other" option is selected', async () => {

package/dist/published/components/custom/FormV2/components/FormFieldTypes/relatedObjectFiles/InstanceLookup.d.ts

@@ -0,0 +1,15 @@
+import { Obj, ObjectInstance, TableViewLayout } from '@evoke-platform/context';
+import React from 'react';
+import { BaseProps } from '../../types';
+export type InstanceLookUpProps = BaseProps & {
+    object: Obj;
+    instanceId?: string;
+    setSelectedInstance: (selectedInstance: ObjectInstance) => void;
+    setRelationType: (relationType: 'new' | 'existing') => void;
+    mode: 'default' | 'existingOnly';
+    nestedFieldsView?: boolean;
+    filter?: Record<string, unknown>;
+    layout?: TableViewLayout;
+};
+declare const InstanceLookup: (props: InstanceLookUpProps) => React.JSX.Element;
+export default InstanceLookup;

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

@@ -0,0 +1,226 @@
+import { useApiServices } from '@evoke-platform/context';
+import { Clear, Search } from '@mui/icons-material';
+import { debounce, get, startCase } from 'lodash';
+import { DateTime } from 'luxon';
+import React, { useEffect, useState } from 'react';
+import { Button, IconButton, InputAdornment, TextField, Typography, } from '../../../../../core';
+import { Box, Grid } from '../../../../../layout';
+import BuilderGrid from '../../../../BuilderGrid';
+import { getPrefixedUrl } from '../../utils';
+const SearchField = (props) => {
+    const { searchableColumns, filter, setFilter, searchString, setSearchString } = props;
+    const clearSearch = () => {
+        setSearchString('');
+        setFilter(undefined);
+    };
+    const handleSearch = async (e) => {
+        const searchProperties = searchableColumns.map((column) => {
+            const columnId = column.id;
+            return {
+                [columnId]: {
+                    like: e.target.value,
+                    options: 'i',
+                },
+            };
+        });
+        if (e.target.value.trim() === '' || !e.target.value) {
+            clearSearch();
+        }
+        else {
+            setSearchString(e.target.value);
+            setFilter({
+                ...filter,
+                where: {
+                    or: searchProperties,
+                },
+                limit: 100,
+            });
+        }
+    };
+    return (React.createElement(TextField, { autoFocus: true, placeholder: "Search", value: searchString, onChange: (e) => handleSearch(e), size: "medium", fullWidth: true, sx: { marginBottom: '15px', marginTop: '15px' }, InputProps: {
+            endAdornment: (React.createElement(InputAdornment, { position: "end" },
+                React.createElement(IconButton, { sx: {
+                        visibility: searchString.length > 0 ? 'visible' : 'hidden',
+                    }, onClick: () => clearSearch() },
+                    React.createElement(Clear, { sx: {
+                            fontSize: '22px',
+                        } })))),
+            startAdornment: (React.createElement(InputAdornment, { position: "start" },
+                React.createElement(Search, { sx: { fontSize: '22px', color: '#637381' } }))),
+        } }));
+};
+const InstanceLookup = (props) => {
+    const { object, setSelectedInstance, setRelationType, filter: criteriaFilter, mode, nestedFieldsView, layout, } = props;
+    const [rows, setRows] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const [filter, setFilter] = useState();
+    const [searchString, setSearchString] = useState('');
+    const [searchableColumns] = useState(object.properties?.filter((property) => property.searchable) ?? []);
+    const apiServices = useApiServices();
+    const retrieveColumns = (tableViewLayout) => {
+        let columns = [];
+        if (tableViewLayout?.properties) {
+            for (const prop of tableViewLayout.properties) {
+                const propertyId = prop.id.split('.')[0];
+                const property = object.properties?.find((p) => p.id === propertyId);
+                if (property) {
+                    if (property.type === 'address') {
+                        columns.push({
+                            field: prop.id,
+                            headerName: `${property.name} - ${startCase(prop.id.split('.')[1])}`,
+                            type: 'string',
+                            flex: 1,
+                            valueGetter: (params) => {
+                                return get(params.row, prop.id) ?? '';
+                            },
+                        });
+                    }
+                    else if (property.type === 'object' || property.type === 'user') {
+                        columns.push({
+                            field: prop.id,
+                            headerName: property.name,
+                            type: 'string',
+                            flex: 1,
+                            valueGetter: (params) => {
+                                return (get(params.row, !prop.id.includes('.') ? `${prop.id}.name` : prop.id) ?? '');
+                            },
+                        });
+                    }
+                    else if (property.type === 'document') {
+                        columns.push({
+                            field: prop.id,
+                            headerName: property.name,
+                            type: 'string',
+                            flex: 1,
+                            valueGetter: (params) => {
+                                const row = params.row;
+                                return (row[prop.id]?.map((v) => v.name).join(', ') ??
+                                    '');
+                            },
+                        });
+                    }
+                    else if (property.type === 'date') {
+                        columns.push({
+                            field: prop.id,
+                            headerName: property.name,
+                            type: 'string',
+                            flex: 1,
+                            valueFormatter: (params) => {
+                                if (!params.value) {
+                                    return params.value;
+                                }
+                                // The value should really be typed as string | undefined so once asserted as defined
+                                // the value must be a string.
+                                return DateTime.fromISO(params.value).toLocaleString(DateTime.DATE_SHORT);
+                            },
+                        });
+                    }
+                    else if (property.type === 'date-time') {
+                        columns.push({
+                            field: prop.id,
+                            headerName: property.name,
+                            type: 'string',
+                            flex: 1,
+                            valueFormatter: (params) => {
+                                if (!params.value) {
+                                    return params.value;
+                                }
+                                // The value should really be typed as string | undefined so once asserted as defined
+                                // the value must be a string.
+                                return DateTime.fromISO(params.value).toLocaleString(DateTime.DATETIME_SHORT);
+                            },
+                        });
+                    }
+                    else if (property.type === 'time') {
+                        columns.push({
+                            field: prop.id,
+                            headerName: property.name,
+                            type: 'string',
+                            flex: 1,
+                            valueFormatter: (params) => {
+                                if (!params.value) {
+                                    return params.value;
+                                }
+                                // The value should really be typed as string | undefined so once asserted as defined
+                                // the value must be a string.
+                                return DateTime.fromISO(params.value).toLocaleString(DateTime.TIME_SIMPLE);
+                            },
+                        });
+                    }
+                    else {
+                        columns.push({
+                            field: prop.id,
+                            headerName: property.name,
+                            type: 'string',
+                            flex: 1,
+                        });
+                    }
+                }
+            }
+        }
+        else {
+            const name = object.properties?.find((property) => property.id == 'name');
+            columns = [{ field: 'name', headerName: name?.name ?? 'Name', type: 'string', flex: 1 }];
+        }
+        return columns;
+    };
+    function fetchObjectInstance() {
+        setLoading(true);
+        const combinedFilter = {
+            ...criteriaFilter,
+            ...filter,
+            where: criteriaFilter?.where
+                ? {
+                    and: [criteriaFilter.where, filter?.where],
+                }
+                : filter?.where,
+        };
+        apiServices.get(getPrefixedUrl(`/objects/${object.id}/instances`), { params: { filter: JSON.stringify(combinedFilter) } }, (error, objectInstances) => {
+            if (error) {
+                console.error(error);
+            }
+            else {
+                !!objectInstances && setRows(objectInstances);
+            }
+            setLoading(false);
+        });
+    }
+    useEffect(() => {
+        if (filter || searchString.length) {
+            debounce(() => fetchObjectInstance(), 500)();
+        }
+        else if (searchString === '') {
+            setRows([]);
+        }
+    }, [filter, searchString.length]);
+    return (React.createElement(Grid, { container: true, sx: { paddingBottom: '30px' } },
+        React.createElement(Grid, { item: true, xs: 12 }, searchableColumns.length ? (React.createElement(SearchField, { searchString: searchString, setSearchString: setSearchString, filter: filter, setFilter: setFilter, searchableColumns: searchableColumns })) : (React.createElement(Typography, { sx: { fontSize: '16px', fontWeight: '700' } }, "There are no searchable properties configured for this object"))),
+        React.createElement(BuilderGrid, { item: 'instances', rows: rows, columns: retrieveColumns(layout), onRowClick: (params) => setSelectedInstance(params.row), initialSort: {
+                field: object.viewLayout?.table?.sort?.colId ?? 'name',
+                sort: object.viewLayout?.table?.sort?.sort ?? 'asc',
+            }, sx: {
+                height: '360px',
+                width: '100%',
+            }, hideToolbar: true, loading: loading, hideEmptyContent: true, localeText: {
+                noRowsLabel: searchString.length > 0
+                    ? `No Results Found. Refine your search ${mode !== 'existingOnly' ? 'or create a new record.' : '.'}`
+                    : 'Search to view results',
+            }, noRowsOverlay: React.createElement(Box, { sx: { height: '100%', display: 'flex', justifyContent: 'center', alignItems: 'center' } }, searchString.length > 0 ? (React.createElement(React.Fragment, null,
+                React.createElement(Box, null,
+                    React.createElement(Typography, { sx: {
+                            fontSize: '14px',
+                            fontWeight: 700,
+                            textAlign: 'center',
+                        } }, "No Results Found"),
+                    React.createElement(Typography, { sx: {
+                            fontSize: '14px',
+                            textAlign: 'center',
+                        } },
+                        "Refine your search",
+                        !nestedFieldsView && mode !== 'existingOnly' && (React.createElement(React.Fragment, null,
+                            ' or ',
+                            React.createElement(Button, { variant: "text", onClick: () => setRelationType('new'), sx: {
+                                    padding: '3px 5px',
+                                } }, "enter a new record"))))))) : (React.createElement(Typography, { sx: { fontSize: '16px' } }, "Search to view results"))) })));
+};
+export default InstanceLookup;

package/dist/published/components/custom/FormV2/components/FormFieldTypes/relatedObjectFiles/ObjectPropertyInput.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { ObjectPropertyInputProps } from '../../types';
+declare const ObjectPropertyInput: (props: ObjectPropertyInputProps) => React.JSX.Element;
+export default ObjectPropertyInput;

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

@@ -0,0 +1,439 @@
+import { useApiServices, useApp, useNavigate, } from '@evoke-platform/context';
+import cleanDeep from 'clean-deep';
+import { cloneDeep, debounce, isEmpty, isNil } from 'lodash';
+import Handlebars from 'no-eval-handlebars';
+import React, { useCallback, useEffect, useState } from 'react';
+import { Close } from '../../../../../../icons';
+import { useFormContext } from '../../../../../../theme/hooks';
+import { Autocomplete, Button, Dialog, IconButton, Link, Paper, Snackbar, TextField, Tooltip, Typography, } from '../../../../../core';
+import { Box } from '../../../../../layout';
+import { encodePageSlug, getDefaultPages, getPrefixedUrl, transformToWhere } from '../../utils';
+import RelatedObjectInstance from './RelatedObjectInstance';
+const ObjectPropertyInput = (props) => {
+    const { id, instance, fieldDefinition, handleChangeObjectProperty, nestedFieldsView, readOnly, error, mode, parameters, displayOption, filter, defaultValueCriteria, sortBy, orderBy, isModal, initialValue, fieldHeight, richTextEditor, viewLayout, hasDescription, } = props;
+    const { fetchedOptions, setFetchedOptions } = useFormContext();
+    const { defaultPages, findDefaultPageSlugFor } = useApp();
+    const [selectedInstance, setSelectedInstance] = useState(initialValue || undefined);
+    const [openCreateDialog, setOpenCreateDialog] = useState(false);
+    const [allDefaultPages, setAllDefaultPages] = useState(defaultPages ?? {});
+    const [loadingOptions, setLoadingOptions] = useState(false);
+    const [navigationSlug, setNavigationSlug] = useState(fetchedOptions[`${id}NavigationSlug`]);
+    const [relatedObject, setRelatedObject] = useState(fetchedOptions[`${id}RelatedObject`]);
+    const [dropdownInput, setDropdownInput] = useState();
+    const [openOptions, setOpenOptions] = useState(false);
+    const [hasFetched, setHasFetched] = useState(fetchedOptions[`${id}OptionsHaveFetched`] || false);
+    const [options, setOptions] = useState(fetchedOptions[`${id}Options`] || []);
+    const [layout, setLayout] = useState();
+    const [appId, setAppId] = useState(fetchedOptions[`${id}AppId`]);
+    const [form, setForm] = useState();
+    const [snackbarError, setSnackbarError] = useState({
+        showAlert: false,
+        isError: true,
+    });
+    const DEFAULT_CREATE_ACTION = '_create';
+    const action = relatedObject?.actions?.find((action) => action.id === DEFAULT_CREATE_ACTION);
+    const apiServices = useApiServices();
+    const navigateTo = useNavigate();
+    const updatedCriteria = filter
+        ? {
+            where: transformToWhere(filter),
+        }
+        : undefined;
+    useEffect(() => {
+        if (relatedObject) {
+            let defaultViewLayout;
+            if (relatedObject?.viewLayout?.dropdown && displayOption === 'dropdown') {
+                defaultViewLayout = {
+                    id: 'default',
+                    name: 'Default',
+                    objectId: relatedObject.id,
+                    ...relatedObject.viewLayout.dropdown,
+                };
+            }
+            else if (relatedObject?.viewLayout?.table && displayOption === 'dialogBox') {
+                defaultViewLayout = {
+                    id: 'default',
+                    name: 'Default',
+                    objectId: relatedObject.id,
+                    ...relatedObject.viewLayout.table,
+                };
+            }
+            if (viewLayout) {
+                apiServices
+                    .get(getPrefixedUrl(`/objects/${viewLayout.objectId}/${displayOption === 'dropdown' ? 'dropdown' : 'table'}Layouts/${viewLayout.id}`))
+                    .then(setLayout)
+                    .catch((err) => setLayout(defaultViewLayout));
+            }
+            else {
+                setLayout(defaultViewLayout);
+            }
+        }
+    }, [displayOption, relatedObject, viewLayout]);
+    useEffect(() => {
+        // setting the default value when there is default criteria
+        if (!isEmpty(defaultValueCriteria) && !selectedInstance && (!instance || !instance[id])) {
+            const updatedFilter = cleanDeep({
+                where: transformToWhere({ $and: [defaultValueCriteria, updatedCriteria?.where ?? {}] }),
+                order: orderBy && sortBy ? encodeURIComponent(sortBy + ' ' + orderBy) : undefined,
+                limit: 1,
+            });
+            if (updatedFilter.where) {
+                setLoadingOptions(true);
+                apiServices.get(getPrefixedUrl(`/objects/${fieldDefinition.objectId}/instances?filter=${encodeURIComponent(JSON.stringify(updatedFilter))}`), (error, instances) => {
+                    if (error) {
+                        console.error(error);
+                        setLoadingOptions(false);
+                    }
+                    if (instances && instances.length > 0) {
+                        setSelectedInstance(instances[0]);
+                        handleChangeObjectProperty(id, instances[0]);
+                    }
+                    setLoadingOptions(false);
+                });
+            }
+        }
+    }, [fieldDefinition, defaultValueCriteria, sortBy, orderBy]);
+    const getDropdownOptions = useCallback((name) => {
+        if ((!fetchedOptions[`${id}Options`] ||
+            fetchedOptions[`${id}Options`].length === 0) &&
+            !hasFetched) {
+            setLoadingOptions(true);
+            const updatedFilter = cloneDeep(updatedCriteria) || {};
+            updatedFilter.limit = 100;
+            const { propertyId, direction } = layout?.sort ?? {
+                propertyId: 'name',
+                direction: 'asc',
+            };
+            updatedFilter.order = `${propertyId} ${direction}`;
+            const where = name
+                ? transformToWhere({
+                    name: {
+                        like: name,
+                        options: 'i',
+                    },
+                })
+                : {};
+            updatedFilter.where = updatedFilter.where
+                ? {
+                    and: [updatedFilter.where, where],
+                }
+                : where;
+            apiServices.get(getPrefixedUrl(`/objects/${fieldDefinition.objectId}/instances?filter=${JSON.stringify(updatedFilter)}`), (error, instances) => {
+                if (error) {
+                    console.error(error);
+                    setLoadingOptions(false);
+                }
+                if (instances) {
+                    setOptions(instances);
+                    setLoadingOptions(false);
+                    // so if you go off a section too quickly and it doesn't fetch it re-fetches but doesn't cause an infinite loop
+                    setHasFetched(true);
+                }
+            });
+        }
+    }, [relatedObject, setLoadingOptions, setOptions, fieldDefinition, updatedCriteria, layout]);
+    useEffect(() => {
+        if (displayOption === 'dropdown') {
+            getDropdownOptions();
+        }
+    }, [fieldDefinition, updatedCriteria, displayOption]);
+    useEffect(() => {
+        setSelectedInstance(initialValue);
+    }, [initialValue]);
+    const debouncedGetDropdownOptions = useCallback(debounce(getDropdownOptions, 200), [updatedCriteria]);
+    useEffect(() => {
+        debouncedGetDropdownOptions(dropdownInput);
+        return () => debouncedGetDropdownOptions.cancel();
+    }, [dropdownInput]);
+    useEffect(() => {
+        if (action?.defaultFormId) {
+            apiServices
+                .get(getPrefixedUrl(`data/forms/${action.defaultFormId}`))
+                .then((evokeForm) => {
+                setForm(evokeForm);
+            })
+                .catch((error) => {
+                console.error('Error fetching form:', error);
+            });
+        }
+    }, [action]);
+    useEffect(() => {
+        if (!fetchedOptions[`${id}RelatedObject`]) {
+            apiServices.get(getPrefixedUrl(`/objects/${fieldDefinition.objectId}/effective?sanitizedVersion=true`), (error, object) => {
+                if (error) {
+                    console.error(error);
+                }
+                else {
+                    setRelatedObject(object);
+                }
+            });
+        }
+    }, [fieldDefinition]);
+    useEffect(() => {
+        const fetchDefaultPages = async () => {
+            if (parameters) {
+                const pages = await getDefaultPages(parameters, defaultPages, findDefaultPageSlugFor);
+                setAllDefaultPages(pages);
+            }
+        };
+        fetchDefaultPages();
+    }, []);
+    useEffect(() => {
+        if (fieldDefinition.objectId &&
+            allDefaultPages &&
+            allDefaultPages[fieldDefinition.objectId] &&
+            (!fetchedOptions?.[`${id}NavigationSlug`] || !fetchedOptions[`${id}AppId`])) {
+            apiServices.get(getPrefixedUrl(`/apps/${allDefaultPages[fieldDefinition.objectId].split('/').slice(1, 2)}/pages/${encodePageSlug(allDefaultPages[fieldDefinition.objectId].split('/').slice(2).join('/'))}`), (error, page) => {
+                if (error) {
+                    console.error(error);
+                }
+                else {
+                    setAppId(page?.appId);
+                    setNavigationSlug(page?.slug);
+                }
+            });
+        }
+    }, []);
+    const handleClose = () => {
+        setOpenCreateDialog(false);
+    };
+    const compileExpression = (expression, instance) => {
+        const template = Handlebars.compileAST(expression);
+        return instance ? template(instance) : undefined;
+    };
+    useEffect(() => {
+        if (relatedObject && !fetchedOptions[`${id}RelatedObject`]) {
+            setFetchedOptions({
+                [`${id}RelatedObject`]: relatedObject,
+            });
+        }
+        if (options &&
+            (!fetchedOptions[`${id}Options`] || fetchedOptions[`${id}Options`].length === 0) &&
+            hasFetched &&
+            !fetchedOptions[`${id}OptionsHaveFetched`]) {
+            setFetchedOptions({
+                [`${id}Options`]: options,
+                [`${id}OptionsHaveFetched`]: hasFetched,
+            });
+        }
+        if (navigationSlug && !fetchedOptions[`${id}NavigationSlug`]) {
+            setFetchedOptions({
+                [`${id}NavigationSlug`]: navigationSlug,
+            });
+        }
+    }, [relatedObject, options, hasFetched]);
+    return (React.createElement(React.Fragment, null,
+        displayOption === 'dropdown' ? (React.createElement(React.Fragment, null,
+            React.createElement(Autocomplete, { id: id, fullWidth: true, sortBy: "NONE", open: openOptions, size: fieldHeight, componentsProps: {
+                    popper: {
+                        modifiers: [
+                            {
+                                name: 'flip',
+                                enabled: false,
+                            },
+                        ],
+                    },
+                }, PaperComponent: ({ children }) => {
+                    return (React.createElement(Paper, { sx: {
+                            borderRadius: '12px',
+                            boxShadow: '0px 24px 48px 0px rgba(145, 158, 171, 0.2)',
+                            '& .MuiAutocomplete-listbox': {
+                                maxHeight: '25vh',
+                            },
+                            '& .MuiAutocomplete-noOptions': {
+                                fontFamily: 'sans-serif',
+                                fontSize: '14px',
+                                paddingLeft: '24px',
+                                color: 'rgba(145, 158, 171, 1)',
+                            },
+                            '& .MuiAutocomplete-loading': {
+                                fontFamily: 'sans-serif',
+                                fontSize: '14px',
+                                paddingLeft: '24px',
+                                color: 'rgba(145, 158, 171, 1)',
+                            },
+                        } },
+                        mode !== 'newOnly' && children,
+                        mode !== 'existingOnly' && form && (React.createElement(Button, { fullWidth: true, sx: {
+                                justifyContent: 'flex-start',
+                                pl: 2,
+                                minHeight: '48px',
+                                borderTop: '1px solid rgba(145, 158, 171, 0.24)',
+                                borderRadius: '0p 0pc 6px 6px',
+                                paddingLeft: '22px',
+                                fontWeight: 400,
+                            }, onMouseDown: (e) => {
+                                setOpenCreateDialog(true);
+                            }, color: 'inherit' }, "+ Add New"))));
+                }, sx: {
+                    '& button.MuiButtonBase-root': {
+                        ...(!loadingOptions &&
+                            (instance?.[id]?.id || selectedInstance?.id)
+                            ? {
+                                visibility: 'visible',
+                            }
+                            : {}),
+                    },
+                    backgroundColor: 'white', // prevents the field flickering gray when loading in the value and options when it's a read only
+                }, noOptionsText: 'No options available', renderOption: (props, option) => {
+                    return (React.createElement("li", { ...props, key: option.id },
+                        React.createElement(Box, null,
+                            React.createElement(Typography, { sx: { marginLeft: '8px', fontSize: '14px' } }, option.label),
+                            layout?.secondaryTextExpression ? (React.createElement(Typography, { sx: { marginLeft: '8px', fontSize: '14px', color: '#637381' } }, compileExpression(layout?.secondaryTextExpression, options.find((o) => o.id === option.value)))) : null)));
+                }, onOpen: () => {
+                    if (instance?.[id]?.id || selectedInstance?.id) {
+                        setOpenOptions(false);
+                    }
+                    else {
+                        setOpenOptions(true);
+                    }
+                }, onClose: () => setOpenOptions(false), value: selectedInstance?.id
+                    ? {
+                        value: selectedInstance?.id ?? '',
+                        label: selectedInstance?.name ?? '',
+                    }
+                    : null, isOptionEqualToValue: (option, value) => {
+                    if (typeof value === 'string') {
+                        return option.value === value;
+                    }
+                    return option.value === value?.value;
+                }, options: options.map((o) => ({ label: o.name, value: o.id })), getOptionLabel: (option) => {
+                    return typeof option === 'string'
+                        ? (options.find((o) => o.id === option)?.name ?? '')
+                        : option.label;
+                }, onKeyDownCapture: (e) => {
+                    // prevents keyboard trap
+                    if (e.key === 'Tab') {
+                        return;
+                    }
+                    if (selectedInstance?.id) {
+                        e.preventDefault();
+                    }
+                }, loading: loadingOptions, onChange: (event, value) => {
+                    if (isNil(value)) {
+                        setDropdownInput(undefined);
+                        setSelectedInstance(undefined);
+                        handleChangeObjectProperty(id, null);
+                    }
+                    else {
+                        const selectedInstance = options.find((o) => o.id === value?.value);
+                        setSelectedInstance(selectedInstance);
+                        handleChangeObjectProperty(id, selectedInstance);
+                    }
+                }, selectOnFocus: false, onBlur: () => setDropdownInput(undefined), renderInput: (params) => (React.createElement(TextField, { ...params, placeholder: selectedInstance?.id || readOnly ? '' : 'Select', readOnly: !loadingOptions && !selectedInstance?.id && readOnly, onChange: (event) => setDropdownInput(event.target.value), onClick: (e) => {
+                        if (openOptions &&
+                            e.target?.nodeName === 'svg') {
+                            setOpenOptions(false);
+                        }
+                        else {
+                            setOptions(options);
+                            setOpenOptions(true);
+                        }
+                    }, sx: {
+                        ...(!loadingOptions && selectedInstance?.id
+                            ? {
+                                '.MuiOutlinedInput-root': {
+                                    background: 'white',
+                                    border: 'auto',
+                                    '.MuiOutlinedInput-input': {
+                                        ...(navigationSlug
+                                            ? {
+                                                color: 'rgb(1, 78, 123)',
+                                                textDecoration: 'underline',
+                                                cursor: 'pointer',
+                                            }
+                                            : {}),
+                                    },
+                                },
+                                '& fieldset': {
+                                    border: readOnly ? 'none' : 'auto',
+                                    borderColor: 'auto',
+                                },
+                                '&:hover .MuiOutlinedInput-notchedOutline': {
+                                    border: 'auto',
+                                },
+                                '& svg': {
+                                    display: readOnly ? 'none' : 'block',
+                                },
+                                caretColor: 'white',
+                            }
+                            : {}),
+                    }, InputProps: {
+                        ...params.InputProps,
+                        startAdornment: selectedInstance?.id ? (React.createElement(Typography, { onClick: (e) => {
+                                if (navigationSlug && selectedInstance?.id) {
+                                    navigateTo(`/${appId}/${navigationSlug.replace(':instanceId', selectedInstance.id)}`);
+                                }
+                            }, sx: {
+                                cursor: navigationSlug ? 'pointer' : 'default',
+                                color: navigationSlug ? 'rgb(1, 78, 123)' : 'inherit',
+                                textDecoration: navigationSlug ? 'underline' : 'none',
+                                paddingLeft: '5px',
+                            } }, selectedInstance?.name || '')) : null,
+                    }, inputProps: {
+                        ...params.inputProps,
+                        value: selectedInstance?.id ? '' : params.inputProps.value,
+                        ...(hasDescription ? { 'aria-describedby': `${id}-description` } : undefined),
+                    } })), readOnly: readOnly, error: error }))) : (React.createElement(Box, { sx: {
+                padding: selectedInstance?.name ? '16.5px 14px' : '10.5px 0',
+            } },
+            (selectedInstance?.name || readOnly) && (React.createElement(Link, { sx: {
+                    textDecoration: 'none',
+                    marginRight: 1,
+                    textDecorationLine: navigationSlug && instance?.[id] && !isModal ? 'underline' : 'none',
+                    cursor: navigationSlug && instance?.[id] && !isModal ? 'pointer' : 'auto',
+                    fontSize: '16px',
+                    fontWeight: 400,
+                    lineHeight: '24px',
+                    textAlign: 'left',
+                    color: navigationSlug && instance?.[id] && !isModal
+                        ? '#0075A7'
+                        : !selectedInstance?.id
+                            ? '#999'
+                            : '#212B36',
+                }, variant: "body2", href: navigationSlug && !isModal
+                    ? `${'/app'}/${appId}/${navigationSlug.replace(':instanceId', selectedInstance?.id ?? '')}`
+                    : undefined, "aria-label": selectedInstance?.name }, selectedInstance?.name ? selectedInstance?.name : readOnly && 'None')),
+            !readOnly && (selectedInstance || (nestedFieldsView && instance?.id)) ? (React.createElement(Tooltip, { title: `Unlink` },
+                React.createElement("span", null,
+                    React.createElement(IconButton, { onClick: (event) => {
+                            event.stopPropagation();
+                            handleChangeObjectProperty(id, null);
+                            setSelectedInstance(undefined);
+                        }, sx: { p: 0, marginBottom: '4px' }, "aria-label": `Unlink` },
+                        React.createElement(Close, { sx: { width: '20px', height: '20px' } }))))) : (React.createElement(Button, { sx: {
+                    backgroundColor: '#DFE3E8',
+                    color: '#212B36',
+                    fontWeight: '700',
+                    textTransform: 'capitalize',
+                    '&:hover': {
+                        backgroundColor: '#e6eaf0',
+                        boxShadow: 'none',
+                    },
+                    '&:disabled': {
+                        cursor: 'not-allowed',
+                        pointerEvents: 'all',
+                    },
+                    boxShadow: 'none',
+                    lineHeight: '2.75',
+                    padding: '0 23px',
+                    display: readOnly ? 'none' : 'block',
+                }, size: "small", variant: "contained", disableElevation: true, onClick: (event) => {
+                    event.stopPropagation();
+                    setOpenCreateDialog(true);
+                }, "aria-label": `Add` }, "Add")))),
+        openCreateDialog && (React.createElement(React.Fragment, null, nestedFieldsView ? (React.createElement(RelatedObjectInstance, { id: id, handleClose: handleClose, handleChangeObjectProperty: handleChangeObjectProperty, setSelectedInstance: setSelectedInstance, relatedObject: relatedObject, nestedFieldsView: nestedFieldsView, mode: mode, displayOption: displayOption, setOptions: setOptions, options: options, filter: updatedCriteria, layout: layout, fieldHeight: fieldHeight, richTextEditor: richTextEditor, form: form, action: action, setSnackbarError: setSnackbarError, selectedInstance: selectedInstance })) : (React.createElement(Dialog, { fullWidth: true, maxWidth: "md", open: openCreateDialog, onClose: (e, reason) => reason !== 'backdropClick' && handleClose },
+            React.createElement(Typography, { sx: {
+                    marginTop: '28px',
+                    fontSize: '22px',
+                    fontWeight: 700,
+                    marginLeft: '24px',
+                    marginBottom: '10px',
+                } }, `Add ${fieldDefinition.name}`),
+            React.createElement(RelatedObjectInstance, { handleClose: handleClose, handleChangeObjectProperty: handleChangeObjectProperty, setSelectedInstance: setSelectedInstance, nestedFieldsView: nestedFieldsView, relatedObject: relatedObject, id: id, mode: mode, displayOption: displayOption, setOptions: setOptions, options: options, filter: updatedCriteria, layout: layout, fieldHeight: fieldHeight, richTextEditor: richTextEditor, form: form, action: action, setSnackbarError: setSnackbarError, selectedInstance: selectedInstance }))))),
+        React.createElement(Snackbar, { open: snackbarError.showAlert, handleClose: () => setSnackbarError({
+                isError: snackbarError.isError,
+                showAlert: false,
+            }), message: snackbarError.message, error: snackbarError.isError })));
+};
+export default ObjectPropertyInput;

package/dist/published/components/custom/FormV2/components/FormFieldTypes/relatedObjectFiles/RelatedObjectInstance.d.ts

@@ -0,0 +1,29 @@
+import { Action, EvokeForm, Obj, ObjectInstance, TableViewLayout } from '@evoke-platform/context';
+import React, { ComponentType } from 'react';
+import { BaseProps, SimpleEditorProps } from '../../types';
+export type RelatedObjectInstanceProps = BaseProps & {
+    relatedObject: Obj | undefined;
+    id: string;
+    setSelectedInstance: (selectedInstance: ObjectInstance) => void;
+    handleChangeObjectProperty: (propertyId: string, instance?: any) => void;
+    handleClose: () => void;
+    mode: 'default' | 'existingOnly' | 'newOnly';
+    setSnackbarError: React.Dispatch<React.SetStateAction<{
+        showAlert: boolean;
+        message?: string;
+        isError: boolean;
+    }>>;
+    nestedFieldsView?: boolean;
+    displayOption?: 'dropdown' | 'dialogBox';
+    setOptions: (options: ObjectInstance[]) => void;
+    options: ObjectInstance[];
+    filter?: Record<string, unknown>;
+    layout?: TableViewLayout;
+    fieldHeight?: 'small' | 'medium';
+    richTextEditor?: ComponentType<SimpleEditorProps>;
+    form?: EvokeForm;
+    action?: Action;
+    selectedInstance?: ObjectInstance;
+};
+declare const RelatedObjectInstance: (props: RelatedObjectInstanceProps) => React.JSX.Element;
+export default RelatedObjectInstance;

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

@@ -0,0 +1,74 @@
+import { InfoRounded } from '@mui/icons-material';
+import React, { useState } from 'react';
+import { Alert, Button, FormControlLabel, Radio, RadioGroup } from '../../../../../core';
+import { Box, Grid } from '../../../../../layout';
+import InstanceLookup from './InstanceLookup';
+const styles = {
+    actionButtons: {
+        padding: '8px 8px 24px 8px',
+        marginRight: '18px',
+        display: 'flex',
+        justifyContent: 'flex-end',
+        alignItems: 'center',
+    },
+};
+const RelatedObjectInstance = (props) => {
+    const { relatedObject, id, setSelectedInstance, handleChangeObjectProperty, handleClose, nestedFieldsView, mode, displayOption, filter, layout, form, } = props;
+    const [errors, setErrors] = useState([]);
+    const [selectedRow, setSelectedRow] = useState();
+    const [relationType, setRelationType] = useState(displayOption === 'dropdown' ? 'new' : 'existing');
+    const linkExistingInstance = async () => {
+        if (selectedRow) {
+            setSelectedInstance(selectedRow);
+            handleChangeObjectProperty(id, selectedRow);
+        }
+        onClose();
+    };
+    const onClose = () => {
+        handleClose();
+        setErrors([]);
+    };
+    return (React.createElement(Box, { sx: {
+            background: nestedFieldsView ? '#F4F6F8' : 'none',
+            borderRadius: '8px',
+        } },
+        React.createElement(Box, { sx: {
+                padding: '8px 24px 0px',
+                '.MuiInputBase-root': { background: '#FFFF', borderRadius: '8px' },
+            } },
+            !nestedFieldsView &&
+                displayOption !== 'dropdown' &&
+                mode !== 'existingOnly' &&
+                mode !== 'newOnly' &&
+                form && (React.createElement(Grid, { container: true },
+                React.createElement(Grid, { container: true, item: true },
+                    React.createElement(RadioGroup, { row: true, "aria-labelledby": "related-object-link-type", onChange: (event) => {
+                            event.target.value === 'existing' && setErrors([]);
+                            setRelationType(event.target.value);
+                        }, value: relationType },
+                        React.createElement(FormControlLabel, { value: "existing", control: React.createElement(Radio, { sx: { '&.Mui-checked': { color: 'primary' } } }), label: "Existing" }),
+                        React.createElement(FormControlLabel, { value: "new", control: React.createElement(Radio, { sx: { '&.Mui-checked': { color: 'primary' } } }), label: "New" }))))),
+            errors?.length ? (React.createElement(Alert, { severity: "error", sx: { margin: '10px 0', borderRadius: '8px' }, icon: React.createElement(InfoRounded, { sx: { color: '#A22723' } }) }, errors.length === 1 ? (React.createElement(React.Fragment, null,
+                "There is ",
+                React.createElement("strong", null, "1"),
+                " error")) : (React.createElement(React.Fragment, null,
+                "There are ",
+                React.createElement("strong", null, errors.length),
+                " errors")))) : undefined,
+            (relationType === 'new' || mode === 'newOnly') && form ? (React.createElement(Box, { id: 'related-object-wrapper', sx: { width: '100%' } })) : (relatedObject &&
+                mode !== 'newOnly' && (React.createElement(React.Fragment, null,
+                React.createElement(InstanceLookup, { colspan: 12, nestedFieldsView: nestedFieldsView, setRelationType: setRelationType, object: relatedObject, setSelectedInstance: setSelectedRow, mode: mode, filter: filter, layout: layout }))))),
+        relationType !== 'new' && mode !== 'newOnly' && (React.createElement(Box, { sx: styles.actionButtons },
+            React.createElement(Button, { onClick: onClose, color: 'inherit', sx: {
+                    border: '1px solid #ced4da',
+                    width: '75px',
+                    marginRight: '0px',
+                    color: 'black',
+                } }, "Cancel"),
+            React.createElement(Button, { sx: {
+                    marginLeft: '8px',
+                    width: '85px',
+                    '&:hover': { boxShadow: 'none' },
+                }, onClick: linkExistingInstance, variant: "contained", disabled: !selectedRow, "aria-label": `Add` }, "Add")))));
+};
+export default RelatedObjectInstance;

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

@@ -1,3 +1,7 @@
+import { InputParameter, ObjectInstance, Property, ViewLayoutEntityReference } from '@evoke-platform/context';
+import { GridSize } from '@mui/material';
+import { ComponentType } from 'react';
+import { FieldValues } from 'react-hook-form';
 export type FieldAddress = {
     line1?: string;
     line2?: string;
@@ -24,3 +28,60 @@ export type Document = {
     };
     versionId?: string;
 };
+export type SimpleEditorProps = {
+    id: string;
+    value: string;
+    handleUpdate?: (value: string) => void;
+    format: 'rtf' | 'plain' | 'openxml';
+    disabled?: boolean;
+    rows?: number;
+    hasError?: boolean;
+    viewHistory?: boolean;
+};
+export type ObjectPropertyInputProps = {
+    id: string;
+    instance?: FieldValues;
+    fieldDefinition: InputParameter;
+    handleChangeObjectProperty: (propertyId: string, instance?: ObjectInstance | null) => void;
+    mode: 'default' | 'existingOnly' | 'newOnly';
+    nestedFieldsView?: boolean;
+    readOnly?: boolean;
+    error?: boolean;
+    displayOption?: 'dropdown' | 'dialogBox';
+    filter?: Record<string, unknown>;
+    defaultValueCriteria?: Record<string, unknown>;
+    sortBy?: string;
+    orderBy?: string;
+    isModal?: boolean;
+    label?: string;
+    initialValue?: ObjectInstance | null;
+    fieldHeight?: 'small' | 'medium';
+    richTextEditor?: ComponentType<SimpleEditorProps>;
+    viewLayout?: ViewLayoutEntityReference;
+    hasDescription?: boolean;
+    parameters?: InputParameter[];
+};
+export type Page = {
+    id: string;
+    name: string;
+    slug?: string;
+    pk?: string;
+    appId?: string;
+    pathParameters?: {
+        id: string;
+    }[];
+    children?: unknown[];
+};
+export type SearchFieldProps = {
+    searchableColumns: Property[];
+    filter: Record<string, unknown> | undefined;
+    setFilter: (filter: Record<string, unknown> | undefined) => void;
+    searchString: string;
+    setSearchString: (searchString: string) => void;
+};
+export type BaseProps = {
+    colspan?: GridSize;
+    baseUrl?: string;
+    getWidgetState?: () => any;
+    saveWidgetState?: (widgetState: unknown) => void;
+};

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

@@ -33,3 +33,7 @@ export declare const getMiddleObjectFilter: (fieldDefinition: InputParameter | P
         [x: string]: string;
     };
 };
+export declare const encodePageSlug: (slug: string) => string;
+export declare function getDefaultPages(parameters: InputParameter[], defaultPages: Record<string, string> | undefined, findDefaultPageSlugFor: (objectId: string) => Promise<string | undefined>): Promise<{
+    [x: string]: string;
+}>;

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

@@ -247,3 +247,23 @@ export const getMiddleObjectFilter = (fieldDefinition, instanceId) => {
     const filter = { where: { [filterProperty]: instanceId } };
     return filter;
 };
+export const encodePageSlug = (slug) => {
+    return encodeURIComponent(encodeURIComponent(slug));
+};
+export async function getDefaultPages(parameters, defaultPages, findDefaultPageSlugFor) {
+    let foundDefaultPages = defaultPages;
+    const relatedObjectProperties = parameters?.filter((param) => param.type === 'object');
+    if (relatedObjectProperties) {
+        foundDefaultPages = await relatedObjectProperties.reduce(async (acc, parameter) => {
+            const result = await acc;
+            if (parameter.objectId && defaultPages && defaultPages[parameter.objectId]) {
+                const slug = await findDefaultPageSlugFor(parameter.objectId);
+                if (slug) {
+                    return { ...result, [parameter.objectId]: slug };
+                }
+            }
+            return result;
+        }, Promise.resolve({}));
+    }
+    return { ...defaultPages, ...foundDefaultPages };
+}

package/dist/published/components/custom/ResponsiveOverflow/ResponsiveOverflow.js

@@ -60,21 +60,17 @@ export const ResponsiveOverflow = (props) => {
             }
         });
         const availableWidth = containerRef.current.getBoundingClientRect().width;
+        const moreButtonWidth = moreButtonBoxRef.current?.getBoundingClientRect().width ?? 0;
         let usedWidth = 0;
         let maxFit = children.length;
-        // Determine which items fit and which overflow
+        // Determine which items fit, accounting for overflow button width
         for (let i = 0; i < itemRefs.current.length; i++) {
             const item = itemRefs.current[i];
             if (!item) {
                 continue;
             }
             const itemWidth = item.getBoundingClientRect().width;
-            // Calculate if we need the "More" button
-            const remainingItems = itemRefs.current.length - i - 1;
-            const moreButtonWidth = remainingItems > 0 && moreButtonBoxRef.current
-                ? moreButtonBoxRef.current.getBoundingClientRect().width
-                : 0;
-            if (usedWidth + itemWidth + (remainingItems > 0 ? moreButtonWidth : 0) > availableWidth) {
+            if (usedWidth + itemWidth + moreButtonWidth > availableWidth) {
                 maxFit = i;
                 break;
             }

package/dist/published/stories/FormField.stories.js

@@ -10,8 +10,7 @@ InputField.args = {
     property: {
         id: 'fullName',
         name: 'Full Name',
-        type: 'text',
-        // enum?: string[],
+        type: 'string',
         required: true,
     },
     onChange: (id, value) => console.log('id= ', id, 'Value= ', value),

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@evoke-platform/ui-components",
-    "version": "1.6.0-dev.20",
+    "version": "1.6.0-dev.22",
     "description": "",
     "main": "dist/published/index.js",
     "module": "dist/published/index.js",