@oneblink/apps-react 2.2.0 → 2.3.0-beta.2

package/dist/hooks/useFormElementOptions.d.ts

@@ -1,9 +1,9 @@
-import { FormTypes } from '@oneblink/types';
-import { FormElementValueChangeHandler } from '../types/form';
-export default function useFormElementOptions<T>({ element, value, onChange, conditionallyShownOptions, onFilter, }: {
-    element: FormTypes.FormElementWithOptions;
-    value: unknown | undefined;
-    onChange: FormElementValueChangeHandler<T>;
-    conditionallyShownOptions: FormTypes.ChoiceElementOption[] | undefined;
-    onFilter?: (choiceElementOption: FormTypes.ChoiceElementOption) => boolean;
-}): FormTypes.ChoiceElementOption[];
+import { FormTypes } from '@oneblink/types';
+import { FormElementValueChangeHandler } from '../types/form';
+export default function useFormElementOptions<T>({ element, value, onChange, conditionallyShownOptions, onFilter, }: {
+    element: FormTypes.FormElementWithOptions;
+    value: unknown | undefined;
+    onChange: FormElementValueChangeHandler<T>;
+    conditionallyShownOptions: FormTypes.ChoiceElementOption[] | undefined;
+    onFilter?: (choiceElementOption: FormTypes.ChoiceElementOption) => boolean;
+}): FormTypes.ChoiceElementOption[];

package/dist/hooks/useFormElementOptions.js

@@ -1,36 +1,36 @@
-import * as React from 'react';
-export default function useFormElementOptions({ element, value, onChange, conditionallyShownOptions, onFilter, }) {
-    const filteredOptions = React.useMemo(() => {
-        if (!element.options) {
-            return [];
-        }
-        if (!conditionallyShownOptions && !onFilter) {
-            return element.options;
-        }
-        return element.options.filter((option) => {
-            return ((!conditionallyShownOptions ||
-                conditionallyShownOptions.some(({ id }) => id === option.id)) &&
-                (!onFilter || onFilter(option)));
-        });
-    }, [conditionallyShownOptions, element.options, onFilter]);
-    React.useEffect(() => {
-        if (!element.options) {
-            return;
-        }
-        if (typeof value === 'string' &&
-            value &&
-            !filteredOptions.some((option) => value === option.value)) {
-            onChange(element, undefined);
-            return;
-        }
-        if (Array.isArray(value)) {
-            const newValue = value.filter((selectedValue) => filteredOptions.some((option) => selectedValue === option.value));
-            if (newValue.length !== value.length) {
-                const newValueArray = newValue.length ? newValue : undefined;
-                onChange(element, newValueArray);
-            }
-        }
-    }, [element, filteredOptions, onChange, value]);
-    return filteredOptions;
-}
+import * as React from 'react';
+export default function useFormElementOptions({ element, value, onChange, conditionallyShownOptions, onFilter, }) {
+    const filteredOptions = React.useMemo(() => {
+        if (!element.options) {
+            return [];
+        }
+        if (!conditionallyShownOptions && !onFilter) {
+            return element.options;
+        }
+        return element.options.filter((option) => {
+            return ((!conditionallyShownOptions ||
+                conditionallyShownOptions.some(({ id }) => id === option.id)) &&
+                (!onFilter || onFilter(option)));
+        });
+    }, [conditionallyShownOptions, element.options, onFilter]);
+    React.useEffect(() => {
+        if (!element.options) {
+            return;
+        }
+        if (typeof value === 'string' &&
+            value &&
+            !filteredOptions.some((option) => value === option.value)) {
+            onChange(element, undefined);
+            return;
+        }
+        if (Array.isArray(value)) {
+            const newValue = value.filter((selectedValue) => filteredOptions.some((option) => selectedValue === option.value));
+            if (newValue.length !== value.length) {
+                const newValueArray = newValue.length ? newValue : undefined;
+                onChange(element, newValueArray);
+            }
+        }
+    }, [element, filteredOptions, onChange, value]);
+    return filteredOptions;
+}
 //# sourceMappingURL=useFormElementOptions.js.map

package/dist/hooks/useFormIsReadOnly.d.ts

@@ -1,3 +1,3 @@
-import * as React from 'react';
-export declare const FormIsReadOnlyContext: React.Context<boolean>;
-export default function useFormIsReadOnly(): boolean;
+import * as React from 'react';
+export declare const FormIsReadOnlyContext: React.Context<boolean>;
+export default function useFormIsReadOnly(): boolean;

package/dist/hooks/useFormIsReadOnly.js

@@ -1,6 +1,6 @@
-import * as React from 'react';
-export const FormIsReadOnlyContext = React.createContext(false);
-export default function useFormIsReadOnly() {
-    return React.useContext(FormIsReadOnlyContext);
-}
+import * as React from 'react';
+export const FormIsReadOnlyContext = React.createContext(false);
+export default function useFormIsReadOnly() {
+    return React.useContext(FormIsReadOnlyContext);
+}
 //# sourceMappingURL=useFormIsReadOnly.js.map

package/dist/hooks/useFormSubmissionAutoSaveState.d.ts

@@ -1,24 +1,24 @@
-import { submissionService } from '@oneblink/apps';
-import { FormTypes } from '@oneblink/types';
-import { FormSubmissionModel } from '../types/form';
-export default function useFormSubmissionAutoSaveState({ form, initialSubmission, removeAutoSaveDataBeforeSubmit, removeAutoSaveDataBeforeSaveDraft, autoSaveKey, onCancel, onSubmit, onSaveDraft, }: {
-    form: FormTypes.Form;
-    removeAutoSaveDataBeforeSubmit?: boolean;
-    removeAutoSaveDataBeforeSaveDraft?: boolean;
-    autoSaveKey: string;
-    onCancel: () => unknown;
-    onSubmit: (newFormSubmission: submissionService.NewFormSubmission) => unknown;
-    initialSubmission?: FormSubmissionModel;
-    onSaveDraft?: (newDraftSubmission: submissionService.NewDraftSubmission) => unknown;
-}): {
-    definition: FormTypes.Form;
-    submission: FormSubmissionModel;
-    isLoadingAutoSaveSubmission: boolean;
-    isAutoSaveSubmissionAvailable: boolean;
-    startNewSubmission: () => void;
-    continueAutoSaveSubmission: () => void;
-    handleSubmit: (submissionResult: any) => void;
-    handleCancel: () => void;
-    handleSaveDraft: ((newDraftSubmission: submissionService.NewDraftSubmission) => void) | undefined;
-    setFormSubmission: (formSubmission: any) => void;
-};
+import { submissionService } from '@oneblink/apps';
+import { FormTypes } from '@oneblink/types';
+import { FormSubmissionModel } from '../types/form';
+export default function useFormSubmissionAutoSaveState({ form, initialSubmission, removeAutoSaveDataBeforeSubmit, removeAutoSaveDataBeforeSaveDraft, autoSaveKey, onCancel, onSubmit, onSaveDraft, }: {
+    form: FormTypes.Form;
+    removeAutoSaveDataBeforeSubmit?: boolean;
+    removeAutoSaveDataBeforeSaveDraft?: boolean;
+    autoSaveKey: string;
+    onCancel: () => unknown;
+    onSubmit: (newFormSubmission: submissionService.NewFormSubmission) => unknown;
+    initialSubmission?: FormSubmissionModel;
+    onSaveDraft?: (newDraftSubmission: submissionService.NewDraftSubmission) => unknown;
+}): {
+    definition: FormTypes.Form;
+    submission: FormSubmissionModel;
+    isLoadingAutoSaveSubmission: boolean;
+    isAutoSaveSubmissionAvailable: boolean;
+    startNewSubmission: () => void;
+    continueAutoSaveSubmission: () => void;
+    handleSubmit: (submissionResult: any) => void;
+    handleCancel: () => void;
+    handleSaveDraft: ((newDraftSubmission: submissionService.NewDraftSubmission) => void) | undefined;
+    setFormSubmission: (formSubmission: any) => void;
+};

package/dist/hooks/useFormSubmissionAutoSaveState.js

@@ -1,146 +1,146 @@
-import * as React from 'react';
-import _throttle from 'lodash.throttle';
-import { autoSaveService, Sentry } from '@oneblink/apps';
-import useFormSubmissionState from './useFormSubmissionState';
-export default function useFormSubmissionAutoSaveState({ form, initialSubmission, removeAutoSaveDataBeforeSubmit, removeAutoSaveDataBeforeSaveDraft, autoSaveKey, onCancel, onSubmit, onSaveDraft, }) {
-    const [{ definition, submission }, setFormSubmission] = useFormSubmissionState(form, initialSubmission);
-    const [{ isLoadingAutoSaveSubmission, autoSaveSubmission }, setAutoSaveState,] = React.useState({
-        isLoadingAutoSaveSubmission: true,
-        autoSaveSubmission: null,
-    });
-    const throttledAutoSave = React.useMemo(() => {
-        return _throttle((model) => {
-            console.log('Auto saving...');
-            autoSaveService
-                .upsertAutoSaveData(definition.id, autoSaveKey, model)
-                .catch((error) => {
-                console.warn('Error while auto saving', error);
-                Sentry.captureException(error);
-            });
-        }, 9580, // https://en.wikipedia.org/wiki/100_metres
-        { trailing: true, leading: false });
-    }, [autoSaveKey, definition.id]);
-    const cancelAutoSave = React.useCallback(() => {
-        if (throttledAutoSave) {
-            throttledAutoSave.cancel();
-        }
-    }, [throttledAutoSave]);
-    const deleteAutoSaveSubmission = React.useCallback(() => {
-        return autoSaveService
-            .deleteAutoSaveData(definition.id, autoSaveKey)
-            .catch((error) => {
-            console.warn('Error removing auto save data: ', error);
-            Sentry.captureException(error);
-        });
-    }, [autoSaveKey, definition.id]);
-    const handleSubmit = React.useCallback((submissionResult) => {
-        cancelAutoSave();
-        if (removeAutoSaveDataBeforeSubmit !== false) {
-            deleteAutoSaveSubmission();
-        }
-        onSubmit(submissionResult);
-    }, [
-        cancelAutoSave,
-        deleteAutoSaveSubmission,
-        onSubmit,
-        removeAutoSaveDataBeforeSubmit,
-    ]);
-    const handleSaveDraft = React.useMemo(() => {
-        if (onSaveDraft) {
-            return (newDraftSubmission) => {
-                cancelAutoSave();
-                if (removeAutoSaveDataBeforeSaveDraft !== false) {
-                    deleteAutoSaveSubmission();
-                }
-                if (onSaveDraft) {
-                    onSaveDraft(newDraftSubmission);
-                }
-            };
-        }
-    }, [
-        cancelAutoSave,
-        deleteAutoSaveSubmission,
-        onSaveDraft,
-        removeAutoSaveDataBeforeSaveDraft,
-    ]);
-    const handleCancel = React.useCallback(() => {
-        cancelAutoSave();
-        deleteAutoSaveSubmission();
-        onCancel();
-    }, [cancelAutoSave, deleteAutoSaveSubmission, onCancel]);
-    React.useEffect(() => {
-        let ignore = false;
-        const loadAutoSaveData = async () => {
-            try {
-                const autoSaveData = await autoSaveService.getAutoSaveData(definition.id, autoSaveKey);
-                if (!ignore) {
-                    setAutoSaveState({
-                        isLoadingAutoSaveSubmission: false,
-                        autoSaveSubmission: autoSaveData,
-                    });
-                }
-            }
-            catch (error) {
-                console.warn('Error loading auto save data', error);
-                Sentry.captureException(error);
-                if (!ignore) {
-                    setAutoSaveState({
-                        isLoadingAutoSaveSubmission: false,
-                        autoSaveSubmission: null,
-                    });
-                }
-            }
-        };
-        loadAutoSaveData();
-        return () => {
-            ignore = true;
-        };
-    }, [autoSaveKey, definition.id]);
-    // Clean up throttle function on unmount
-    React.useEffect(() => {
-        return () => {
-            cancelAutoSave();
-        };
-    }, [cancelAutoSave]);
-    const setFormSubmissionAutoSave = React.useCallback((formSubmission) => {
-        setFormSubmission((currentFormSubmission) => {
-            const newFormSubmission = typeof formSubmission === 'function'
-                ? formSubmission(currentFormSubmission)
-                : formSubmission;
-            throttledAutoSave(newFormSubmission.submission);
-            return newFormSubmission;
-        });
-    }, [setFormSubmission, throttledAutoSave]);
-    const startNewSubmission = React.useCallback(() => {
-        deleteAutoSaveSubmission();
-        setAutoSaveState({
-            isLoadingAutoSaveSubmission: false,
-            autoSaveSubmission: null,
-        });
-    }, [deleteAutoSaveSubmission]);
-    const continueAutoSaveSubmission = React.useCallback(() => {
-        if (autoSaveSubmission) {
-            setFormSubmission((currentFormSubmission) => ({
-                ...currentFormSubmission,
-                submission: autoSaveSubmission,
-            }));
-        }
-        setAutoSaveState({
-            isLoadingAutoSaveSubmission: false,
-            autoSaveSubmission: null,
-        });
-    }, [autoSaveSubmission, setFormSubmission]);
-    return {
-        definition,
-        submission,
-        isLoadingAutoSaveSubmission,
-        isAutoSaveSubmissionAvailable: autoSaveSubmission !== null,
-        startNewSubmission,
-        continueAutoSaveSubmission,
-        handleSubmit,
-        handleCancel,
-        handleSaveDraft,
-        setFormSubmission: setFormSubmissionAutoSave,
-    };
-}
+import * as React from 'react';
+import _throttle from 'lodash.throttle';
+import { autoSaveService, Sentry } from '@oneblink/apps';
+import useFormSubmissionState from './useFormSubmissionState';
+export default function useFormSubmissionAutoSaveState({ form, initialSubmission, removeAutoSaveDataBeforeSubmit, removeAutoSaveDataBeforeSaveDraft, autoSaveKey, onCancel, onSubmit, onSaveDraft, }) {
+    const [{ definition, submission }, setFormSubmission] = useFormSubmissionState(form, initialSubmission);
+    const [{ isLoadingAutoSaveSubmission, autoSaveSubmission }, setAutoSaveState,] = React.useState({
+        isLoadingAutoSaveSubmission: true,
+        autoSaveSubmission: null,
+    });
+    const throttledAutoSave = React.useMemo(() => {
+        return _throttle((model) => {
+            console.log('Auto saving...');
+            autoSaveService
+                .upsertAutoSaveData(definition.id, autoSaveKey, model)
+                .catch((error) => {
+                console.warn('Error while auto saving', error);
+                Sentry.captureException(error);
+            });
+        }, 9580, // https://en.wikipedia.org/wiki/100_metres
+        { trailing: true, leading: false });
+    }, [autoSaveKey, definition.id]);
+    const cancelAutoSave = React.useCallback(() => {
+        if (throttledAutoSave) {
+            throttledAutoSave.cancel();
+        }
+    }, [throttledAutoSave]);
+    const deleteAutoSaveSubmission = React.useCallback(() => {
+        return autoSaveService
+            .deleteAutoSaveData(definition.id, autoSaveKey)
+            .catch((error) => {
+            console.warn('Error removing auto save data: ', error);
+            Sentry.captureException(error);
+        });
+    }, [autoSaveKey, definition.id]);
+    const handleSubmit = React.useCallback((submissionResult) => {
+        cancelAutoSave();
+        if (removeAutoSaveDataBeforeSubmit !== false) {
+            deleteAutoSaveSubmission();
+        }
+        onSubmit(submissionResult);
+    }, [
+        cancelAutoSave,
+        deleteAutoSaveSubmission,
+        onSubmit,
+        removeAutoSaveDataBeforeSubmit,
+    ]);
+    const handleSaveDraft = React.useMemo(() => {
+        if (onSaveDraft) {
+            return (newDraftSubmission) => {
+                cancelAutoSave();
+                if (removeAutoSaveDataBeforeSaveDraft !== false) {
+                    deleteAutoSaveSubmission();
+                }
+                if (onSaveDraft) {
+                    onSaveDraft(newDraftSubmission);
+                }
+            };
+        }
+    }, [
+        cancelAutoSave,
+        deleteAutoSaveSubmission,
+        onSaveDraft,
+        removeAutoSaveDataBeforeSaveDraft,
+    ]);
+    const handleCancel = React.useCallback(() => {
+        cancelAutoSave();
+        deleteAutoSaveSubmission();
+        onCancel();
+    }, [cancelAutoSave, deleteAutoSaveSubmission, onCancel]);
+    React.useEffect(() => {
+        let ignore = false;
+        const loadAutoSaveData = async () => {
+            try {
+                const autoSaveData = await autoSaveService.getAutoSaveData(definition.id, autoSaveKey);
+                if (!ignore) {
+                    setAutoSaveState({
+                        isLoadingAutoSaveSubmission: false,
+                        autoSaveSubmission: autoSaveData,
+                    });
+                }
+            }
+            catch (error) {
+                console.warn('Error loading auto save data', error);
+                Sentry.captureException(error);
+                if (!ignore) {
+                    setAutoSaveState({
+                        isLoadingAutoSaveSubmission: false,
+                        autoSaveSubmission: null,
+                    });
+                }
+            }
+        };
+        loadAutoSaveData();
+        return () => {
+            ignore = true;
+        };
+    }, [autoSaveKey, definition.id]);
+    // Clean up throttle function on unmount
+    React.useEffect(() => {
+        return () => {
+            cancelAutoSave();
+        };
+    }, [cancelAutoSave]);
+    const setFormSubmissionAutoSave = React.useCallback((formSubmission) => {
+        setFormSubmission((currentFormSubmission) => {
+            const newFormSubmission = typeof formSubmission === 'function'
+                ? formSubmission(currentFormSubmission)
+                : formSubmission;
+            throttledAutoSave(newFormSubmission.submission);
+            return newFormSubmission;
+        });
+    }, [setFormSubmission, throttledAutoSave]);
+    const startNewSubmission = React.useCallback(() => {
+        deleteAutoSaveSubmission();
+        setAutoSaveState({
+            isLoadingAutoSaveSubmission: false,
+            autoSaveSubmission: null,
+        });
+    }, [deleteAutoSaveSubmission]);
+    const continueAutoSaveSubmission = React.useCallback(() => {
+        if (autoSaveSubmission) {
+            setFormSubmission((currentFormSubmission) => ({
+                ...currentFormSubmission,
+                submission: autoSaveSubmission,
+            }));
+        }
+        setAutoSaveState({
+            isLoadingAutoSaveSubmission: false,
+            autoSaveSubmission: null,
+        });
+    }, [autoSaveSubmission, setFormSubmission]);
+    return {
+        definition,
+        submission,
+        isLoadingAutoSaveSubmission,
+        isAutoSaveSubmissionAvailable: autoSaveSubmission !== null,
+        startNewSubmission,
+        continueAutoSaveSubmission,
+        handleSubmit,
+        handleCancel,
+        handleSaveDraft,
+        setFormSubmission: setFormSubmissionAutoSave,
+    };
+}
 //# sourceMappingURL=useFormSubmissionAutoSaveState.js.map

package/dist/hooks/useFormSubmissionModelContext.d.ts

@@ -1,15 +1,15 @@
-import { FormTypes } from '@oneblink/types';
-import * as React from 'react';
-import { FormElementsConditionallyShown, FormSubmissionModel } from '../types/form';
-export declare type FormSubmissionModelContextValue = {
-    formSubmissionModel: FormSubmissionModel;
-    parent?: FormSubmissionModelContextValue;
-};
-export declare function FormSubmissionModelContextProvider({ children, model, elements, formElementsConditionallyShown, }: {
-    model: FormSubmissionModel;
-    elements: FormTypes.FormElement[] | undefined;
-    formElementsConditionallyShown: FormElementsConditionallyShown | undefined;
-    children: React.ReactNode;
-}): JSX.Element;
-export default function useFormSubmissionModel(): FormSubmissionModelContextValue;
-export declare function useFormSubmissionModelParent(): FormSubmissionModelContextValue;
+import { FormTypes } from '@oneblink/types';
+import * as React from 'react';
+import { FormElementsConditionallyShown, FormSubmissionModel } from '../types/form';
+export declare type FormSubmissionModelContextValue = {
+    formSubmissionModel: FormSubmissionModel;
+    parent?: FormSubmissionModelContextValue;
+};
+export declare function FormSubmissionModelContextProvider({ children, model, elements, formElementsConditionallyShown, }: {
+    model: FormSubmissionModel;
+    elements: FormTypes.FormElement[] | undefined;
+    formElementsConditionallyShown: FormElementsConditionallyShown | undefined;
+    children: React.ReactNode;
+}): JSX.Element;
+export default function useFormSubmissionModel(): FormSubmissionModelContextValue;
+export declare function useFormSubmissionModelParent(): FormSubmissionModelContextValue;

package/dist/hooks/useFormSubmissionModelContext.js

@@ -1,33 +1,33 @@
-import * as React from 'react';
-import cleanFormSubmissionModel from '../services/cleanFormSubmissionModel';
-const FormSubmissionModelContext = React.createContext(undefined);
-export function FormSubmissionModelContextProvider({ children, model, elements, formElementsConditionallyShown, }) {
-    const formSubmissionModelContext = React.useContext(FormSubmissionModelContext);
-    const value = React.useMemo(() => {
-        return {
-            formSubmissionModel: cleanFormSubmissionModel(model, elements || [], formElementsConditionallyShown, true).model,
-            parent: formSubmissionModelContext,
-        };
-    }, [
-        model,
-        elements,
-        formElementsConditionallyShown,
-        formSubmissionModelContext,
-    ]);
-    return (React.createElement(FormSubmissionModelContext.Provider, { value: value }, children));
-}
-export default function useFormSubmissionModel() {
-    const formSubmissionModelContext = React.useContext(FormSubmissionModelContext);
-    if (!formSubmissionModelContext) {
-        throw new Error('"FormSubmissionModelContext" does not have a value in this context');
-    }
-    return formSubmissionModelContext;
-}
-export function useFormSubmissionModelParent() {
-    let formSubmissionModelContext = useFormSubmissionModel();
-    while (formSubmissionModelContext.parent) {
-        formSubmissionModelContext = formSubmissionModelContext.parent;
-    }
-    return formSubmissionModelContext;
-}
+import * as React from 'react';
+import cleanFormSubmissionModel from '../services/cleanFormSubmissionModel';
+const FormSubmissionModelContext = React.createContext(undefined);
+export function FormSubmissionModelContextProvider({ children, model, elements, formElementsConditionallyShown, }) {
+    const formSubmissionModelContext = React.useContext(FormSubmissionModelContext);
+    const value = React.useMemo(() => {
+        return {
+            formSubmissionModel: cleanFormSubmissionModel(model, elements || [], formElementsConditionallyShown, true).model,
+            parent: formSubmissionModelContext,
+        };
+    }, [
+        model,
+        elements,
+        formElementsConditionallyShown,
+        formSubmissionModelContext,
+    ]);
+    return (React.createElement(FormSubmissionModelContext.Provider, { value: value }, children));
+}
+export default function useFormSubmissionModel() {
+    const formSubmissionModelContext = React.useContext(FormSubmissionModelContext);
+    if (!formSubmissionModelContext) {
+        throw new Error('"FormSubmissionModelContext" does not have a value in this context');
+    }
+    return formSubmissionModelContext;
+}
+export function useFormSubmissionModelParent() {
+    let formSubmissionModelContext = useFormSubmissionModel();
+    while (formSubmissionModelContext.parent) {
+        formSubmissionModelContext = formSubmissionModelContext.parent;
+    }
+    return formSubmissionModelContext;
+}
 //# sourceMappingURL=useFormSubmissionModelContext.js.map

package/dist/hooks/useFormSubmissionState.d.ts

@@ -1,10 +1,10 @@
-import * as React from 'react';
-import { FormTypes } from '@oneblink/types';
-import { FormSubmissionModel } from '../types/form';
-export default function useFormSubmissionState(form: FormTypes.Form, initialSubmission?: FormSubmissionModel): [{
-    definition: FormTypes.Form;
-    submission: FormSubmissionModel;
-}, React.Dispatch<React.SetStateAction<{
-    definition: FormTypes.Form;
-    submission: FormSubmissionModel;
-}>>];
+import * as React from 'react';
+import { FormTypes } from '@oneblink/types';
+import { FormSubmissionModel } from '../types/form';
+export default function useFormSubmissionState(form: FormTypes.Form, initialSubmission?: FormSubmissionModel): [{
+    definition: FormTypes.Form;
+    submission: FormSubmissionModel;
+}, React.Dispatch<React.SetStateAction<{
+    definition: FormTypes.Form;
+    submission: FormSubmissionModel;
+}>>];

package/dist/hooks/useFormSubmissionState.js

@@ -1,14 +1,14 @@
-import * as React from 'react';
-import _cloneDeep from 'lodash.clonedeep';
-import generateDefaultData from '../services/generate-default-data';
-export default function useFormSubmissionState(form, initialSubmission) {
-    return React.useState(() => {
-        const definition = _cloneDeep(form);
-        const defaultData = generateDefaultData(definition.elements, initialSubmission || {});
-        return {
-            definition,
-            submission: defaultData,
-        };
-    });
-}
+import * as React from 'react';
+import _cloneDeep from 'lodash.clonedeep';
+import generateDefaultData from '../services/generate-default-data';
+export default function useFormSubmissionState(form, initialSubmission) {
+    return React.useState(() => {
+        const definition = _cloneDeep(form);
+        const defaultData = generateDefaultData(definition.elements, initialSubmission || {});
+        return {
+            definition,
+            submission: defaultData,
+        };
+    });
+}
 //# sourceMappingURL=useFormSubmissionState.js.map

package/dist/hooks/useFormValidation.d.ts

@@ -1,7 +1,7 @@
-import { FormTypes } from '@oneblink/types';
-import { FormElementsConditionallyShown, FormSubmissionModel } from '../types/form';
-export default function useFormValidation(pages: FormTypes.PageElement[]): {
-    executedLookup: (element: FormTypes.LookupFormElement) => void;
-    executeLookupFailed: (element: FormTypes.LookupFormElement) => void;
-    validate: (submission: FormSubmissionModel, formElementsConditionallyShown: FormElementsConditionallyShown) => import("../types/form").FormElementsValidation | undefined;
-};
+import { FormTypes } from '@oneblink/types';
+import { FormElementsConditionallyShown, FormSubmissionModel } from '../types/form';
+export default function useFormValidation(pages: FormTypes.PageElement[]): {
+    executedLookup: (element: FormTypes.LookupFormElement) => void;
+    executeLookupFailed: (element: FormTypes.LookupFormElement) => void;
+    validate: (submission: FormSubmissionModel, formElementsConditionallyShown: FormElementsConditionallyShown) => import("../types/form").FormElementsValidation | undefined;
+};