@evoke-platform/ui-components 1.6.0-testing.12 → 1.6.0-testing.14

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

@@ -0,0 +1,131 @@
+import { ExpandMoreOutlined } from '@mui/icons-material';
+import { nanoid } from 'nanoid';
+import React, { useEffect } from 'react';
+import { useResponsive } from '../../../../theme';
+import { Accordion, AccordionDetails, AccordionSummary, Typography } from '../../../core';
+import { Box } from '../../../layout';
+import { RecursiveEntryRenderer } from './RecursiveEntryRenderer';
+import { getErrorCountForSection } from './utils';
+function AccordionSections(props) {
+    const { entry, handleChange, fieldHeight, richTextEditor, instance, expandedSections, setExpandedSections, expandAll, setExpandAll, errors, parameters, triggerFieldReset, showSubmitError, } = props;
+    const { isMd, isLg, isXl } = useResponsive();
+    const lastSection = entry.sections.length - 1;
+    const sectionsWithIds = React.useMemo(() => assignIds(entry.sections), [entry]);
+    function collectNestedSections(entries = []) {
+        const nestedSections = [];
+        entries.forEach((entry) => {
+            if (entry.type === 'sections') {
+                nestedSections.push(entry);
+            }
+            else if (entry.type === 'columns') {
+                const columnEntry = entry;
+                columnEntry.columns.forEach((column) => {
+                    const columnSections = collectNestedSections(column.entries);
+                    nestedSections.push(...columnSections);
+                });
+            }
+        });
+        return nestedSections;
+    }
+    // need to add ids to section so expanded sections can differentiate between sections with the same label
+    function assignIds(sections) {
+        const result = [];
+        sections.forEach((section) => {
+            const newSection = {
+                ...section,
+                id: nanoid(),
+            };
+            result.push(newSection);
+            if (section.entries) {
+                const nestedSections = collectNestedSections(section.entries);
+                nestedSections.forEach((nestedSection) => {
+                    nestedSection.sections = assignIds(nestedSection.sections);
+                });
+            }
+        });
+        return result;
+    }
+    function getExpandedSections(sections, expandAll) {
+        const expandedSections = [];
+        const processSections = (sectionList) => {
+            sectionList.forEach((section, index) => {
+                expandedSections.push({
+                    label: section.label,
+                    expanded: expandAll ?? (index === 0 || isMd || isLg || isXl),
+                    id: section?.id,
+                });
+                if (section.entries) {
+                    const nestedSections = collectNestedSections(section.entries).flatMap((s) => s.sections);
+                    processSections(nestedSections);
+                }
+            });
+        };
+        processSections(sections);
+        return expandedSections;
+    }
+    useEffect(() => {
+        if (expandAll !== null) {
+            setExpandedSections(getExpandedSections(sectionsWithIds, expandAll));
+        }
+    }, [expandAll, sectionsWithIds]);
+    const handleAccordionChange = (id) => {
+        const updatedSections = expandedSections.map((section) => section.id === id ? { ...section, expanded: !section.expanded } : section);
+        setExpandedSections(updatedSections);
+        setExpandAll(null);
+    };
+    return (React.createElement(Box, null, sectionsWithIds.map((section, sectionIndex) => {
+        const errorCount = getErrorCountForSection(section, errors);
+        return (React.createElement(Accordion, { key: section.id, expanded: expandedSections.find((expandedSection) => expandedSection.id === section.id)?.expanded ??
+                !!expandAll, onChange: () => handleAccordionChange(section.id), defaultExpanded: sectionIndex === 0, sx: {
+                border: '1px solid #dbe0e4',
+                boxShadow: 'none',
+                marginBottom: '16px',
+                borderRadius: '6px',
+                '&:before': {
+                    display: 'none',
+                },
+            } },
+            React.createElement(AccordionSummary, { sx: {
+                    '&.Mui-expanded': {
+                        borderBottom: '1px solid #dbe0e4',
+                        minHeight: '44px',
+                        borderBottomLeftRadius: '0px',
+                        borderBottomRightRadius: '0px',
+                    },
+                    minHeight: '44px',
+                    maxHeight: '44px',
+                    backgroundColor: '#F4F6F8',
+                    borderRadius: '5px',
+                    // MUI accordion summaries have different border radius for the first and last item
+                    borderTopLeftRadius: sectionIndex === 0 ? '3px' : undefined,
+                    borderTopRightRadius: sectionIndex === 0 ? '3px' : undefined,
+                    borderBottomRightRadius: sectionIndex === lastSection ? '3px' : undefined,
+                    borderBottomLeftRadius: sectionIndex === lastSection ? '3px' : undefined,
+                }, expandIcon: React.createElement(ExpandMoreOutlined, { fontSize: "medium" }) },
+                React.createElement(Box, { sx: {
+                        display: 'flex',
+                        alignItems: 'center',
+                        width: '100%',
+                        justifyContent: 'space-between',
+                    } },
+                    React.createElement(Typography, { sx: {
+                            fontWeight: '600',
+                        } }, section.label),
+                    errorCount > 0 && showSubmitError && (React.createElement(Box, { sx: {
+                            ml: 1,
+                            bgcolor: '#FF4842',
+                            color: 'white',
+                            borderRadius: '50%',
+                            minWidth: '20px',
+                            minHeight: '20px',
+                            display: 'flex',
+                            justifyContent: 'center',
+                            alignItems: 'center',
+                            fontSize: '12px',
+                            margin: '0px',
+                            marginRight: '16px',
+                        } }, errorCount)))),
+            React.createElement(AccordionDetails, null, section.entries?.map((sectionEntry, index) => (React.createElement(RecursiveEntryRenderer, { key: sectionEntry.type + index, entry: sectionEntry, handleChange: handleChange, errors: errors, fieldHeight: fieldHeight, richTextEditor: richTextEditor, instance: instance, expandedSections: expandedSections, setExpandedSections: setExpandedSections, expandAll: expandAll, setExpandAll: setExpandAll, parameters: parameters, triggerFieldReset: triggerFieldReset, showSubmitError: showSubmitError }))))));
+    })));
+}
+export default AccordionSections;

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

@@ -0,0 +1,19 @@
+import { ActionType, FormEntry } from '@evoke-platform/context';
+import React from 'react';
+import { FieldErrors, FieldValues, UseFormReturn, UseFormSetValue, UseFormUnregister } from 'react-hook-form';
+type ActionButtonProps = {
+    onSubmit: (data: FieldValues) => void;
+    handleSubmit: UseFormReturn['handleSubmit'];
+    isModal: boolean;
+    submitButtonLabel?: string;
+    actionType?: ActionType;
+    onReset: () => void;
+    errors?: FieldErrors;
+    unregister: UseFormUnregister<FieldValues>;
+    entries: FormEntry[];
+    setValue: UseFormSetValue<FieldValues>;
+    formId?: string;
+    instance?: FieldValues;
+};
+declare function ActionButtons(props: ActionButtonProps): React.JSX.Element;
+export default ActionButtons;

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

@@ -0,0 +1,106 @@
+import { isEmpty, omit } from 'lodash';
+import React, { useContext, useState } from 'react';
+import { useResponsive } from '../../../../theme';
+import { Button, LoadingButton } from '../../../core';
+import { Box } from '../../../layout';
+import { FormContext } from './FormContext';
+import { entryIsVisible, getEntryId, getNestedParameterIds, isAddressProperty, scrollIntoViewWithOffset, } from './utils';
+function ActionButtons(props) {
+    const { onSubmit, submitButtonLabel, actionType, handleSubmit, onReset, unregister, errors, isModal, entries, setValue, formId, instance, } = props;
+    const { isXs } = useResponsive();
+    const [isSubmitLoading, setIsSubmitLoading] = useState(false);
+    const { getValues } = useContext(FormContext);
+    const unregisterHiddenFields = (entriesToCheck) => {
+        entriesToCheck.forEach((entry) => {
+            if (entry.type === 'sections' || entry.type === 'columns') {
+                const subEntries = entry.type === 'sections' ? entry.sections : entry.columns;
+                subEntries.forEach((subEntry) => {
+                    if (subEntry.entries) {
+                        unregisterHiddenFields(subEntry.entries);
+                    }
+                });
+            }
+            if (!entryIsVisible(entry, getValues(), instance)) {
+                if (entry.type === 'sections' || entry.type === 'columns') {
+                    const fieldsToUnregister = getNestedParameterIds(entry);
+                    fieldsToUnregister.forEach(processFieldUnregister);
+                }
+                else {
+                    const fieldId = getEntryId(entry);
+                    if (fieldId)
+                        processFieldUnregister(fieldId);
+                }
+            }
+        });
+    };
+    const processFieldUnregister = (fieldId) => {
+        if (isAddressProperty(fieldId)) {
+            // Unregister entire 'address' to clear hidden field errors, then restore existing values since unregistering address.line1 etc is not working
+            let addressValues = getValues('address');
+            addressValues = omit(addressValues, fieldId.split('.')[1]);
+            unregister('address');
+            setValue('address', addressValues);
+        }
+        else {
+            unregister(fieldId);
+        }
+    };
+    async function showErrorsOrSubmit() {
+        setIsSubmitLoading(true);
+        unregisterHiddenFields(entries ?? []);
+        try {
+            await handleSubmit((data) => onSubmit(actionType === 'delete' ? {} : data))();
+        }
+        finally {
+            setIsSubmitLoading(false);
+        }
+        if (!isEmpty(errors)) {
+            setTimeout(() => {
+                const errorElement = document.getElementById(`validation-error-display-${formId}`);
+                let modal = errorElement?.closest('.MuiPaper-root');
+                const hasCloseIcon = modal?.querySelector('svg[data-testid="CloseIcon"]');
+                modal = hasCloseIcon ? document.querySelector('.MuiDialogContent-root') : modal;
+                if (errorElement) {
+                    scrollIntoViewWithOffset(errorElement, 170, modal);
+                }
+            }, 0);
+        }
+    }
+    return (React.createElement(Box, { sx: {
+            display: 'flex',
+            justifyContent: 'flex-end',
+            flexWrap: 'wrap-reverse',
+            width: '100%',
+        } },
+        React.createElement(Button, { key: "cancel", variant: "outlined", sx: {
+                margin: '5px',
+                marginX: isXs ? '0px' : undefined,
+                color: 'black',
+                border: '1px solid rgb(206, 212, 218)',
+                width: isXs ? '100%' : 'auto',
+                '&:hover': {
+                    backgroundColor: '#f2f4f7',
+                    border: '1px solid rgb(206, 212, 218)',
+                },
+            }, onClick: () => onReset() }, isModal ? 'Cancel' : 'Discard Changes'),
+        React.createElement(LoadingButton, { key: "submit", variant: "contained", sx: {
+                lineHeight: '2.75',
+                margin: '5px 0 5px 5px',
+                marginX: isXs ? '0px' : undefined,
+                padding: '0 23px',
+                backgroundColor: actionType === 'delete' ? '#A12723' : 'primary',
+                borderRadius: '8px',
+                boxShadow: 'none',
+                whiteSpace: 'nowrap',
+                width: isXs ? '100%' : 'auto',
+                '& .MuiCircularProgress-root': {
+                    color: 'white',
+                },
+                '&:hover': {
+                    backgroundColor: actionType === 'delete' ? ' #8C2421' : '#014E7B',
+                },
+            }, onClick: () => {
+                showErrorsOrSubmit();
+            }, loading: isSubmitLoading }, submitButtonLabel || 'Submit')));
+}
+export default ActionButtons;

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

@@ -0,0 +1,24 @@
+import React, { ReactNode } from 'react';
+type FieldWrapperProps = {
+    inputId: string;
+    inputType: string;
+    label: string;
+    description?: string;
+    tooltip?: string;
+    prefix?: string;
+    suffix?: string;
+    value?: unknown;
+    errorMessage?: string;
+    showCharCount?: boolean;
+    viewOnly: boolean;
+    children: ReactNode;
+    required: boolean;
+    fieldHeight?: 'small' | 'medium';
+    maxLength?: number;
+};
+/**
+ * A component that wraps a FormField and adds a label,
+ * description, tooltip, prefix, suffix and word/char counts
+ */
+declare const FieldWrapper: (props: FieldWrapperProps) => React.JSX.Element;
+export default FieldWrapper;

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

@@ -0,0 +1,100 @@
+import { Help, InfoRounded } from '@mui/icons-material';
+import React from 'react';
+import { IconButton, InputLabel, Tooltip, Typography } from '../../../core';
+import { Box } from '../../../layout';
+const underFieldStyles = {
+    display: 'flex',
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    alignItems: 'center',
+};
+const descriptionStyles = {
+    color: '#999',
+    whiteSpace: 'normal',
+    display: 'block',
+};
+const PrefixSuffix = (props) => {
+    const { prefix, suffix, height, isViewOnly } = props;
+    const text = prefix || suffix;
+    const prefixSuffixStyles = {
+        display: 'inline-flex',
+        alignItems: 'center',
+        background: isViewOnly ? undefined : '#f5f5f5',
+        padding: '5px',
+        border: isViewOnly ? undefined : '1px solid #ccc',
+        ...(suffix && {
+            borderTopRightRadius: '5px',
+            borderBottomRightRadius: '5px',
+            marginLeft: '-5px',
+            padding: '7px 5px 7px 10px',
+            marginTop: '6px',
+        }),
+        ...(prefix && {
+            borderTopLeftRadius: '5px',
+            borderBottomLeftRadius: '5px',
+            marginRight: '-5px',
+            padding: '7px 10px 7px 5px',
+            marginTop: '6px',
+        }),
+        height: height === 'small' ? 24 : 40,
+    };
+    if (!prefix && !suffix)
+        return null;
+    return (React.createElement(Box, { sx: prefixSuffixStyles },
+        React.createElement(Typography, null, text)));
+};
+/**
+ * A component that wraps a FormField and adds a label,
+ * description, tooltip, prefix, suffix and word/char counts
+ */
+const FieldWrapper = (props) => {
+    const { inputId, label, description, tooltip, prefix, suffix, value, maxLength, errorMessage, showCharCount, inputType, viewOnly, children, fieldHeight, required, } = props;
+    const charCount = typeof value === 'string' ? value.length : 0;
+    const remainingChars = maxLength ? maxLength - charCount : undefined;
+    return (React.createElement(Box, null,
+        React.createElement(Box, { sx: { padding: '10px 0' } },
+            inputType !== 'boolean' && (React.createElement(InputLabel, { htmlFor: inputId, sx: {
+                    display: 'flex',
+                    alignItems: 'center',
+                    color: viewOnly ? 'text.secondary' : 'text.primary',
+                    fontSize: '14px',
+                } },
+                label,
+                required ? (React.createElement(Typography, { component: 'span', sx: { color: 'red', fontSize: '12px', lineHeight: '22px', paddingLeft: '4px' } }, `*`)) : null,
+                tooltip && (React.createElement(Tooltip, { placement: "right", title: tooltip },
+                    React.createElement(IconButton, null,
+                        React.createElement(Help, { sx: { fontSize: '14px' } })))))),
+            React.createElement(Box, { sx: {
+                    display: 'flex',
+                    flexDirection: 'row',
+                    alignItems: viewOnly ? 'center' : 'flex-start',
+                } },
+                inputType === 'string' && (React.createElement(PrefixSuffix, { prefix: prefix, height: fieldHeight || 'medium', isViewOnly: viewOnly })),
+                React.createElement(Box, { sx: {
+                        width: viewOnly && suffix ? undefined : '100%',
+                        marginTop: '6px',
+                        borderRadius: '8px',
+                    } },
+                    children,
+                    inputType !== 'boolean' && (errorMessage || description || showCharCount) && (React.createElement(Box, { sx: underFieldStyles },
+                        React.createElement(Box, { sx: {
+                                width: '100%',
+                                display: 'flex',
+                                justifyContent: 'space-between',
+                                alignItems: 'flex-start',
+                                flexWrap: 'wrap',
+                                paddingTop: '4px',
+                            } },
+                            React.createElement(Box, { sx: { display: 'flex', flexDirection: 'column' } },
+                                errorMessage ? (React.createElement(Box, { display: 'flex', alignItems: 'center' },
+                                    React.createElement(InfoRounded, { color: 'error', sx: { fontSize: '.75rem', marginRight: '3px' } }),
+                                    React.createElement(Typography, { fontSize: '12px', color: 'error', sx: { lineHeight: '18px' } }, errorMessage))) : (React.createElement("span", null)),
+                                description && (React.createElement(Typography, { id: `${inputId}-description`, variant: "caption", sx: descriptionStyles }, description))),
+                            showCharCount && (React.createElement(Typography, { variant: "caption", sx: { color: '#999999', whiteSpace: 'nowrap' } },
+                                remainingChars ?? charCount,
+                                ' ',
+                                (remainingChars ?? charCount) === 1 ? 'character' : 'characters',
+                                !!maxLength && ` remaining`)))))),
+                inputType === 'string' && (React.createElement(PrefixSuffix, { suffix: suffix, height: fieldHeight || 'medium', isViewOnly: viewOnly }))))));
+};
+export default FieldWrapper;

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

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { Obj } from '@evoke-platform/context';
+import { FieldValues, UseFormGetValues } from 'react-hook-form';
+type FormContextType = {
+    fetchedOptions: FieldValues;
+    setFetchedOptions: (newData: FieldValues) => void;
+    getValues: UseFormGetValues<FieldValues>;
+    stickyFooter?: boolean;
+    object?: Obj;
+};
+export declare const FormContext: import("react").Context<FormContextType>;
+export {};

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

@@ -0,0 +1,8 @@
+import { createContext } from 'react';
+export const FormContext = createContext({
+    fetchedOptions: {},
+    setFetchedOptions: () => { },
+    getValues: (() => ({})),
+    stickyFooter: false,
+    object: undefined,
+});

package/dist/published/components/custom/FormV2/components/FormFieldTypes/AddressFields.d.ts

@@ -0,0 +1,17 @@
+import { InputField, InputParameter, InputParameterReference, Property, ReadonlyField } from '@evoke-platform/context';
+import React from 'react';
+import { FieldErrors, FieldValues } from 'react-hook-form';
+import { Address } from '../../../FormField/AddressFieldComponent';
+interface AddressProps {
+    entry: InputParameterReference | ReadonlyField | InputField;
+    errors?: FieldErrors;
+    handleChange: (propertyId: string, value: string | Address | undefined) => void;
+    fieldHeight?: 'small' | 'medium';
+    readOnly?: boolean;
+    parameters?: InputParameter[];
+    instance?: FieldValues;
+    entryId: string;
+    fieldDefinition: InputParameter | Property;
+}
+declare function AddressFields(props: AddressProps): React.JSX.Element;
+export default AddressFields;

package/dist/published/components/custom/FormV2/components/FormFieldTypes/AddressFields.js

@@ -0,0 +1,50 @@
+import { useApiServices, } from '@evoke-platform/context';
+import React from 'react';
+import { useFormContext } from '../../../../../theme/hooks';
+import { Typography } from '../../../../core';
+import FormField from '../../../FormField';
+import FieldWrapper from '../FieldWrapper';
+import { getPrefixedUrl, isOptionEqualToValue } from '../utils';
+function AddressFields(props) {
+    const { entry, errors, handleChange, fieldHeight, readOnly, parameters, instance, entryId, fieldDefinition } = props;
+    const { getValues } = useFormContext();
+    const apiServices = useApiServices();
+    const addressObject = entryId.split('.')[0];
+    const addressField = entryId.split('.')[1];
+    const addressValues = entry.type === 'readonlyField' ? instance?.[addressObject] : getValues(addressObject);
+    const fieldValue = addressValues?.[addressField];
+    const display = entry?.display;
+    const validation = fieldDefinition?.validation
+        ? fieldDefinition.validation
+        : {};
+    const queryAddresses = async (query) => {
+        return await apiServices.get(getPrefixedUrl(`/locations/search`), {
+            params: { query: query },
+        });
+    };
+    const handleAddressChange = (name, value) => {
+        if (addressField === 'line1' && typeof value === 'object' && value.line1) {
+            const addressKeys = ['line1', 'city', 'county', 'state', 'zipCode'];
+            addressKeys.forEach((key) => {
+                const fullKey = `${addressObject}.${key}`;
+                if (parameters?.some((p) => p.id === fullKey)) {
+                    const fieldValue = value[key];
+                    handleChange(fullKey, fieldValue);
+                }
+            });
+        }
+        else {
+            handleChange(name, value);
+        }
+    };
+    const addressErrors = errors?.[addressObject];
+    const addressFieldError = addressErrors?.[addressField];
+    return (React.createElement(FieldWrapper, { inputId: entryId, inputType: "string", label: display?.label || 'default', description: !readOnly ? display?.description : undefined, tooltip: display?.tooltip, value: fieldValue, maxLength: 'maxLength' in validation ? validation?.maxLength : 0, required: entry.display?.required || false, showCharCount: !readOnly && display?.charCount, viewOnly: !!readOnly, prefix: display?.prefix, suffix: display?.suffix }, !readOnly ? (React.createElement(FormField, { property: fieldDefinition, defaultValue: fieldValue, onChange: handleAddressChange, isMultiLineText: !!display?.rowCount, readOnly: entry.type === 'readonlyField', ...(addressField === 'line1' && { queryAddresses }), mask: validation?.mask, placeholder: display?.placeholder, isOptionEqualToValue: isOptionEqualToValue, size: fieldHeight, error: !!addressFieldError, errorMessage: addressFieldError?.message, additionalProps: {
+            ...(display?.description && {
+                inputProps: {
+                    'aria-describedby': `${entryId}-description`,
+                },
+            }),
+        } })) : (React.createElement(Typography, { variant: "body1", key: entryId, sx: { height: '24px', paddingTop: '6px' } }, fieldValue))));
+}
+export default AddressFields;

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

@@ -0,0 +1,14 @@
+import { Action, ActionType, EvokeForm, InputParameter, Obj } from '@evoke-platform/context';
+import React from 'react';
+export type ActionDialogProps = {
+    open: boolean;
+    onClose: () => void;
+    action: Action;
+    instanceInput: Record<string, unknown>;
+    handleSubmit: (actionType: ActionType, input: Record<string, unknown> | undefined, instanceId?: string, setSubmitting?: (value: boolean) => void) => void;
+    object: Obj;
+    instanceId?: string;
+    relatedParameter?: InputParameter;
+    relatedForm?: EvokeForm;
+};
+export declare const ActionDialog: (props: ActionDialogProps) => React.JSX.Element;

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

@@ -0,0 +1,88 @@
+import { useApiServices } from '@evoke-platform/context';
+import { Close } from '@mui/icons-material';
+import React, { useEffect, useState } from 'react';
+import { Dialog, DialogContent, DialogTitle, IconButton, Skeleton } from '../../../../../core';
+import { Box } from '../../../../../layout';
+import ErrorComponent from '../../../../ErrorComponent';
+import { getPrefixedUrl } from '../../utils';
+const styles = {
+    button: {
+        textTransform: 'initial',
+        fontSize: '14px',
+        fontWeight: 700,
+        marginRight: '10px',
+    },
+    dialogTitle: {
+        fontSize: '18px',
+        fontWeight: 700,
+        paddingTop: '35px',
+        paddingBottom: '20px',
+    },
+    closeIcon: {
+        position: 'absolute',
+        right: '17px',
+        top: '22px',
+    },
+    cancelBtn: {
+        border: '1px solid #ced4da',
+        width: '75px',
+        marginRight: '10px',
+        color: 'black',
+    },
+    deleteBtn: {
+        color: '#ffffff',
+        backgroundColor: '#A12723',
+        '&:hover': { backgroundColor: '#A12723' },
+    },
+};
+export const ActionDialog = (props) => {
+    const { open, onClose, action, object, instanceId, relatedForm, instanceInput } = props;
+    const [loading, setLoading] = useState(false);
+    const [hasAccess, setHasAccess] = useState();
+    const [form, setForm] = useState();
+    const apiServices = useApiServices();
+    const isDeleteAction = action.type === 'delete';
+    useEffect(() => {
+        if (instanceId) {
+            setLoading(true);
+            apiServices.get(getPrefixedUrl(`/objects/${object.id}/instances/${instanceId}/checkAccess`), {
+                params: { action: 'execute', field: action.id },
+            }, (error, result) => {
+                setHasAccess(result?.result ?? false);
+                setLoading(false);
+            });
+        }
+        else {
+            setHasAccess(true);
+            setLoading(false);
+        }
+    }, [object, instanceId]);
+    useEffect(() => {
+        setForm(isDeleteAction && !form
+            ? {
+                id: '',
+                name: '',
+                entries: [
+                    {
+                        type: 'content',
+                        html: `<p>You are about to delete ${instanceInput?.name}. Deleted records can't be restored. Are you sure you want to continue?</p>`,
+                    },
+                ],
+                objectId: object.id,
+                actionId: '_delete',
+                display: {
+                    submitLabel: 'Delete',
+                },
+            }
+            : relatedForm);
+    }, [relatedForm, action, form]);
+    return (React.createElement(Dialog, { maxWidth: 'md', fullWidth: true, open: open, onClose: (e, reason) => reason !== 'backdropClick' && onClose() },
+        React.createElement(DialogTitle, { sx: styles.dialogTitle },
+            React.createElement(IconButton, { sx: styles.closeIcon, onClick: onClose },
+                React.createElement(Close, { fontSize: "small" })),
+            action && hasAccess && !loading ? action?.name : ''),
+        React.createElement(DialogContent, { sx: { paddingBottom: loading ? undefined : '0px' } }, hasAccess ? (React.createElement(Box, { sx: { width: '100%', marginTop: '10px' } })) : (React.createElement(React.Fragment, null, loading ? (React.createElement(React.Fragment, null,
+            React.createElement(Skeleton, { height: '30px', animation: 'wave' }),
+            React.createElement(Skeleton, { height: '30px', animation: 'wave' }),
+            React.createElement(Skeleton, { height: '30px', animation: 'wave' }))) : (React.createElement(ErrorComponent, { code: 'AccessDenied', message: 'You do not have permission to perform this action.', styles: { boxShadow: 'none' } })))))));
+};

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

@@ -0,0 +1,13 @@
+import { ObjectInstance } from '@evoke-platform/context';
+import React from 'react';
+export type DocumentViewerCellProps = {
+    instance: ObjectInstance;
+    propertyId: string;
+    setSnackbarError: (error: {
+        showAlert: boolean;
+        message?: string;
+        isError?: boolean;
+    }) => void;
+    smallerThanMd?: boolean;
+};
+export declare const DocumentViewerCell: (props: DocumentViewerCellProps) => React.JSX.Element;