@bolttech/form-engine 3.0.0-beta.16 → 3.0.0-beta.18

package/index.esm.js

@@ -1616,8 +1616,13 @@ $$1({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }
   assign: assign
 });
 
-let context;
 const FormGroupContext = /*#__PURE__*/createContext({});
+/**
+ * context interface to be used isolated or with the context provider
+ *
+ * @param {TFormContextProvider} param context parameters
+ * @returns {TFormContext}
+ */
 const IsolatedContext = ({
   debugMode: _debugMode = false,
   mappers
@@ -1653,10 +1658,10 @@ const IsolatedContext = ({
   const printFormGroupInstance = () => {
     console.log(formGroupInstance.current.printFormGroupInstance());
   };
-  const submitMultipleFormsByIndex = indexes => {
+  function submitMultipleFormsByIndex(indexes) {
     return formGroupInstance.current.submitMultipleFormsByIndex(indexes);
-  };
-  const contextValue = {
+  }
+  return {
     addFormWithIndex,
     addForm,
     getForm,
@@ -1668,8 +1673,13 @@ const IsolatedContext = ({
     debugMode: _debugMode,
     active: false
   };
-  return contextValue;
 };
+/**
+ * context provider to wrap form-engine adapter elements
+ *
+ * @param {PropsWithChildren<TFormContextProvider>} param context parameters
+ * @returns {ReactElement}
+ */
 const FormGroupContextProvider = ({
   children,
   mappers,
@@ -1691,9 +1701,15 @@ const FormGroupContextProvider = ({
     }), children]
   });
 };
+/**
+ * FormGroup context hook to handle context or isolated context implementations
+ *
+ * @param {TFormContextProvider} props form group context parameters
+ * @returns {TFormContext}
+ */
 const useFormGroupContext = props => {
-  context = useContext(FormGroupContext);
-  if (Object.keys(context).length === 0) {
+  const context = useContext(FormGroupContext);
+  if (Object.keys(context).length === 0 && props) {
     return IsolatedContext({
       debugMode: props.debugMode,
       mappers: props.mappers
@@ -1702,6 +1718,12 @@ const useFormGroupContext = props => {
   return context;
 };
 
+/**
+ * Renders the React element defined on the mappers configuration
+ *
+ * @param param component props, field instance and children to render
+ * @returns
+ */
 const FieldWrapperComponentRender = ({
   props,
   fieldInstance,
@@ -1722,6 +1744,13 @@ const FieldWrapperComponentRender = ({
     children: `failed to render field ${fieldInstance === null || fieldInstance === void 0 ? void 0 : fieldInstance.name} with componentName:${(_c = fieldInstance === null || fieldInstance === void 0 ? void 0 : fieldInstance.mapper) === null || _c === void 0 ? void 0 : _c.componentName}, please check mappers`
   });
 };
+/**
+ * Base field Wrapper to render the component with the necessary configurations from the schema
+ * and mapper configuration
+ *
+ * @param {TFieldWrapperProps} param FieldWrapper params
+ * @returns {ReactElement}
+ */
 const FieldWrapper = ({
   name,
   formIndex,
@@ -1731,37 +1760,40 @@ const FieldWrapper = ({
 }) => {
   var _a;
   const localContext = useFormGroupContext({});
+  /**
+   * picks the right context prioritizing the context passed as prop
+   */
   const {
     formGroupInstance,
     debugMode
   } = useMemo(() => context ? context : localContext, [context, localContext]);
-  const fieldInstance = (_a = formGroupInstance.getForm({
+  const fieldInstance = useRef((_a = formGroupInstance.getForm({
     key: formIndex
   })) === null || _a === void 0 ? void 0 : _a.getField({
     key: name
-  });
-  const [valueState, setValueState] = useState(fieldInstance === null || fieldInstance === void 0 ? void 0 : fieldInstance.stateValue);
+  })).current;
+  const [valueState, setValueState] = useState((fieldInstance === null || fieldInstance === void 0 ? void 0 : fieldInstance.stateValue) || {});
   const [state, setState] = useState({
     visibility: (fieldInstance === null || fieldInstance === void 0 ? void 0 : fieldInstance.visibility) || true,
-    props: (fieldInstance === null || fieldInstance === void 0 ? void 0 : fieldInstance.props) || props,
-    apiResponse: fieldInstance === null || fieldInstance === void 0 ? void 0 : fieldInstance.api
+    props: (fieldInstance === null || fieldInstance === void 0 ? void 0 : fieldInstance.props) || props
   });
+  /**
+   * handles the mounting and unmounting logic onto the field instance
+   */
   useEffect(() => {
     fieldInstance === null || fieldInstance === void 0 ? void 0 : fieldInstance.mountField({
       valueSubscription: value => {
         setValueState(value);
       },
       propsSubscription: ({
-        errors,
         visibility,
-        apiResponse,
-        props
+        props,
+        errors
       }) => {
         setState(prev => Object.assign(Object.assign({}, prev), {
-          errors,
           visibility,
-          apiResponse,
-          props
+          props,
+          errors
         }));
       }
     });
@@ -1769,17 +1801,27 @@ const FieldWrapper = ({
       fieldInstance === null || fieldInstance === void 0 ? void 0 : fieldInstance.destroyField();
     };
   }, []);
+  /**
+   * handles the value change onto the field instance
+   */
   const handleChange = useCallback(event => {
     fieldInstance === null || fieldInstance === void 0 ? void 0 : fieldInstance.emitValue({
       value: event,
       event: 'ON_FIELD_CHANGE'
     });
   }, []);
+  /**
+   * handles the event emission onto the field instance
+   */
   const handleEvent = useCallback(event => {
     fieldInstance === null || fieldInstance === void 0 ? void 0 : fieldInstance.emitEvents({
       event
     });
   }, []);
+  /**
+   * handles the mappers configuration to bind the event submission callback
+   * to the corresponding prop defined on the mappers
+   */
   const mapProps = useMemo(() => {
     var _a;
     const events = (_a = fieldInstance === null || fieldInstance === void 0 ? void 0 : fieldInstance.mapper) === null || _a === void 0 ? void 0 : _a.events;
@@ -1792,13 +1834,6 @@ const FieldWrapper = ({
     if (events === null || events === void 0 ? void 0 : events.onKeyDown) props[events.onKeyDown] = () => handleEvent('ON_FIELD_KEYDOWN');
     return props;
   }, []);
-  const mapValue = useMemo(() => {
-    var _a;
-    const events = (_a = fieldInstance === null || fieldInstance === void 0 ? void 0 : fieldInstance.mapper) === null || _a === void 0 ? void 0 : _a.events;
-    return (events === null || events === void 0 ? void 0 : events.setValue) ? {
-      [events.setValue]: valueState
-    } : {};
-  }, [valueState]);
   return (state === null || state === void 0 ? void 0 : state.visibility) ? jsxs(Fragment, {
     children: [debugMode && jsxs(Fragment, {
       children: [jsx("b", {
@@ -1809,13 +1844,22 @@ const FieldWrapper = ({
         children: name
       }), jsx("br", {}), jsx("hr", {})]
     }), jsx(FieldWrapperComponentRender, {
-      props: Object.assign(Object.assign(Object.assign({}, mapProps), state.props), mapValue),
+      props: Object.assign(Object.assign(Object.assign(Object.assign({}, mapProps), state.props), state.errors), valueState),
       fieldInstance: fieldInstance,
       children: children && children
     })]
   }) : jsx(Fragment, {});
 };
 
+/**
+ * recursive function to transform form fields from a form instance into
+ * a react component tree
+ *
+ * @param {Map<string,IFormField>} param.fields form instance field Map
+ * @param {string} param.prevPath previous field path to track the tree branch creation
+ * @param {string} param.formIndex form index to aid field identification onto the FieldWrapper
+ * @returns {ReactNode}
+ */
 const BuildTree = ({
   fields,
   prevPath,
@@ -1838,6 +1882,12 @@ const BuildTree = ({
     }, fieldName);
   });
 };
+/**
+ * function to transform AsFormField elements onto a JSON schema
+ *
+ * @param param.children ReactNode children elements
+ * @returns {IComponentSchema[] | null | undefined}
+ */
 const BuildAsFormFieldTree = ({
   children
 }) => {
@@ -1890,6 +1940,9 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
+/**
+ * events mapping to aid function callback binding
+ */
 const eventsMapping = {
   ON_FIELD_CHANGE: 'onChange',
   ON_FIELD_BLUR: 'onBlur',
@@ -1901,6 +1954,9 @@ const eventsMapping = {
   ON_FIELD_CLICK: 'onClick'
 };
 
+/**
+ * Hook to register events callback functions
+ */
 const useForm = _a => {
   var {
       id
@@ -1909,10 +1965,18 @@ const useForm = _a => {
   const {
     formGroupInstance
   } = useFormGroupContext({});
+  /**
+   * reference to store all updated callback functions rerendered by props change
+   */
   const callbackRefs = useRef(rest);
   useEffect(() => {
     callbackRefs.current = rest;
   }, [rest]);
+  /**
+   * handle function call after the debounce occurs on the form instance field event
+   * subject in order to call the most updated function with the updated function
+   * reference to avoid events get outdated values
+   */
   useEffect(() => {
     var _a;
     const callback = payload => {
@@ -1932,6 +1996,11 @@ const useForm = _a => {
   return;
 };
 
+/**
+ *
+ * @param {TFormProps} param form properties initializor
+ * @returns {ReactElement}
+ */
 const Form = ({
   schema,
   index,
@@ -1960,6 +2029,9 @@ const Form = ({
   } = useFormGroupContext({});
   const [tree, setTree] = useState();
   const schemaIndex = useMemo(() => index || (schema === null || schema === void 0 ? void 0 : schema.index) || 'defaultChange', [index, schema]);
+  /**
+   * logic to initialize the form instance and it's removal
+   */
   useEffect(() => {
     if (schemaIndex === 'defaultChange') {
       console.warn('please, add an unique id to the form, otherwise multiple forms will break');
@@ -1988,6 +2060,11 @@ const Form = ({
       });
     };
   }, []);
+  /**
+   * logic to transform AsFormFields onto JSON schema
+   * and JSON schema onto FieldWrappers, refreshes when
+   * the react tree changes it's children
+   */
   useEffect(() => {
     var _a;
     const schema = BuildAsFormFieldTree({
@@ -2007,11 +2084,17 @@ const Form = ({
       setTree(buildTree);
     }
   }, [children]);
+  /**
+   * iVars change tracker to update iVars onto form instance
+   */
   useEffect(() => {
     if (iVars) getForm({
       key: index
     }).iVars = iVars;
   }, [iVars]);
+  /**
+   * hook usage to keep event bindings updated on callback functions passed as props
+   */
   useForm({
     id: schemaIndex,
     onApiResponse,
@@ -2066,10 +2149,17 @@ const Form = ({
   });
 };
 
+/**
+ * Component wrapper to aid building schemas with react without writting a JSON schema
+ * along with BuildAsFormFieldTree inside a Form component, FieldWrapper gets this props
+ * to build the component as it does with a JSON schema, this component only works inside
+ * the Form component
+ *
+ * @param {TAsFormFieldProps} props JSON schema props
+ * @returns {ReactNode}
+ */
 const AsFormField = props => {
-  return jsx(Fragment, {
-    children: props.children
-  });
+  return props.children;
 };
 
 var wellKnownSymbol$1 = wellKnownSymbol$8;
@@ -2318,9 +2408,24 @@ $({ target: 'RegExp', proto: true, forced: /./.exec !== exec }, {
   exec: exec
 });
 
+/**
+ * Component Wrapper to render form fields without the Form component, gets additional formId and mapper since
+ * it won't rely on them and needs to be manually declared
+ *
+ * @param {TAsFormFieldBuilderProps} props JSON schema props along with FieldWrapper props and mapper props
+ * @returns {ReactElement}
+ */
 const AsFormFieldBuilder = props => {
   const context = useFormGroupContext({});
+  /**
+   * state to track the field instance creation process
+   */
   const [mounted, setMounted] = useState(false);
+  /**
+   * initializer to create or add a form instance to the formGroup by it's formId
+   * and add the field to the form instance
+   * Also has the logic to remove it once this element is removed
+   */
   useEffect(() => {
     var _a;
     if (!((_a = context.formGroupInstance) === null || _a === void 0 ? void 0 : _a.forms.has(props.formIndex))) {

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@bolttech/form-engine",
-  "version": "3.0.0-beta.16",
+  "version": "3.0.0-beta.18",
   "description": "A react adapter for bolttech form engine",
   "module": "./index.esm.js",
   "type": "module",
   "main": "./index.esm.js",
   "dependencies": {
-    "@bolttech/form-engine-core": "0.0.1-beta.7",
+    "@bolttech/form-engine-core": "0.0.1-beta.9",
     "react": "18.2.0"
   },
   "peerDependencies": {}

package/src/components/AsFormField/AsFormField.d.ts

@@ -1,4 +1,13 @@
-import { IComponentSchema } from '@bolttech/form-engine-core';
-import { PropsWithChildren, ReactElement } from 'react';
-declare const AsFormField: (props: PropsWithChildren<Omit<IComponentSchema, 'children'>>) => ReactElement;
+import { ReactNode } from 'react';
+import { TAsFormFieldProps } from './AsFormField.type';
+/**
+ * Component wrapper to aid building schemas with react without writting a JSON schema
+ * along with BuildAsFormFieldTree inside a Form component, FieldWrapper gets this props
+ * to build the component as it does with a JSON schema, this component only works inside
+ * the Form component
+ *
+ * @param {TAsFormFieldProps} props JSON schema props
+ * @returns {ReactNode}
+ */
+declare const AsFormField: (props: TAsFormFieldProps) => ReactNode;
 export default AsFormField;

package/src/components/AsFormField/AsFormField.type.d.ts

@@ -0,0 +1,9 @@
+import { IComponentSchema } from '@bolttech/form-engine-core';
+import { PropsWithChildren } from 'react';
+/**
+ * AsFormField props, inherits all schema field implementation except the children
+ * property, that will be a ReactNode
+ * @see {@link IComponentSchema}
+ */
+type TAsFormFieldProps = PropsWithChildren<Omit<IComponentSchema, 'children'>>;
+export type { TAsFormFieldProps };

package/src/components/AsFormFieldBuilder/AsFormFieldBuilder.d.ts

@@ -1,7 +1,11 @@
-import { IComponentSchema, TMapper } from '@bolttech/form-engine-core';
-import { ElementType, PropsWithChildren, ReactElement } from 'react';
-import { TFieldWrapper } from '../../types';
-declare const AsFormFieldBuilder: (props: PropsWithChildren<Omit<IComponentSchema, 'children' | 'component'> & Required<TFieldWrapper> & {
-    mapper: TMapper<ElementType>;
-}>) => ReactElement;
+import { ReactElement } from 'react';
+import { TAsFormFieldBuilderProps } from './AsFormFieldBuilder.type';
+/**
+ * Component Wrapper to render form fields without the Form component, gets additional formId and mapper since
+ * it won't rely on them and needs to be manually declared
+ *
+ * @param {TAsFormFieldBuilderProps} props JSON schema props along with FieldWrapper props and mapper props
+ * @returns {ReactElement}
+ */
+declare const AsFormFieldBuilder: (props: TAsFormFieldBuilderProps) => ReactElement;
 export default AsFormFieldBuilder;

package/src/components/AsFormFieldBuilder/AsFormFieldBuilder.type.d.ts

@@ -0,0 +1,16 @@
+import { IComponentSchema, TMapper } from '@bolttech/form-engine-core';
+import { ElementType, PropsWithChildren } from 'react';
+import { TFieldWrapper } from '../../types';
+/**
+ * AsFormField props, inherits all schema field implementation except the children
+ * property, that will be a ReactNode
+ * also gets the formIndex for form identification and the mapper to build the component
+ * @property {TMapper} mapper element mapper to use
+ * @see {@link TMapper}
+ * @see {@link IComponentSchema}
+ * @see {@link TFieldWrapper}
+ */
+type TAsFormFieldBuilderProps = PropsWithChildren<Omit<IComponentSchema, 'children' | 'component' | 'name'> & Required<TFieldWrapper> & {
+    mapper: TMapper<ElementType>;
+}>;
+export type { TAsFormFieldBuilderProps };

package/src/components/FieldWrapper/FieldWrapper.d.ts

@@ -1,9 +1,11 @@
-import { PropsWithChildren, ReactElement } from 'react';
-import { TFormContext } from '../../context/FormGroupContext';
-import { TFieldWrapper } from '../../types';
-declare const FieldWrapper: ({ name, formIndex, children, props, context, }: PropsWithChildren<TFieldWrapper & {
-    name: string;
-    props?: Record<string, unknown> | undefined;
-    context?: TFormContext | null | undefined;
-}>) => ReactElement;
+import { ReactElement } from 'react';
+import { TFieldWrapperProps } from './FieldWrapper.type';
+/**
+ * Base field Wrapper to render the component with the necessary configurations from the schema
+ * and mapper configuration
+ *
+ * @param {TFieldWrapperProps} param FieldWrapper params
+ * @returns {ReactElement}
+ */
+declare const FieldWrapper: ({ name, formIndex, children, props, context, }: TFieldWrapperProps) => ReactElement;
 export default FieldWrapper;

package/src/components/FieldWrapper/FieldWrapper.type.d.ts

@@ -0,0 +1,28 @@
+import { PropsWithChildren } from 'react';
+import { TFieldWrapper } from '../../types';
+import { TFormContext } from '../../context/FormGroupContext';
+import { FormField } from '@bolttech/form-engine-core';
+/**
+ * Represents the props for a field wrapper component, including children.
+ *
+ * @property {Record<string, unknown>} [props] - Additional properties for the field.
+ * @property {TFormContext | null} [context] - The context of the form, which may be null.
+ * @property {React.ReactNode} children - The child elements of the component.
+ * @see {@link TFieldWrapper}
+ */
+type TFieldWrapperProps = PropsWithChildren<TFieldWrapper & {
+    props?: Record<string, unknown>;
+    context?: TFormContext | null;
+}>;
+/**
+ * Represents the props for rendering a field wrapper component, including children.
+ *
+ * @property {Record<string, unknown>} props - Additional properties for the field.
+ * @property {FormField} [fieldInstance] - The instance of the form field, which may be undefined.
+ * @property {React.ReactNode} children - The child elements of the component.
+ */
+type TFieldWrapperComponentRenderProps = PropsWithChildren<{
+    props: Record<string, unknown>;
+    fieldInstance?: FormField;
+}>;
+export type { TFieldWrapperProps, TFieldWrapperComponentRenderProps };

package/src/components/Form/Form.d.ts

@@ -1,5 +1,9 @@
-import { TFormEntry } from '@bolttech/form-engine-core';
-import { PropsWithChildren } from 'react';
-import { TEventsCallbackProps } from '../../types';
-declare const Form: ({ schema, index, initialValues, iVars, action, method, onSubmit, onData, onBlur, onChange, onApiResponse, onClick, onFocus, onKeyDown, onKeyUp, onMount, children, }: PropsWithChildren<Omit<TFormEntry, 'mappers'> & TEventsCallbackProps>) => import("react/jsx-runtime").JSX.Element;
+import { ReactElement } from 'react';
+import { TFormProps } from './Form.type';
+/**
+ *
+ * @param {TFormProps} param form properties initializor
+ * @returns {ReactElement}
+ */
+declare const Form: ({ schema, index, initialValues, iVars, action, method, onSubmit, onData, onBlur, onChange, onApiResponse, onClick, onFocus, onKeyDown, onKeyUp, onMount, children, }: TFormProps) => ReactElement;
 export default Form;

package/src/components/Form/Form.type.d.ts

@@ -0,0 +1,11 @@
+import { TFormEntry } from '@bolttech/form-engine-core';
+import { PropsWithChildren } from 'react';
+import { TEventsCallbackProps } from '../../types';
+/**
+ * Form props, inherits the form instance constructor implementation except the mapper
+ * along with all event callback register props shared with other implementations
+ * @see {@link TFormEntry}
+ * @see {@link TEventsCallbackProps}
+ */
+type TFormProps = PropsWithChildren<Omit<TFormEntry, 'mappers'> & TEventsCallbackProps>;
+export type { TFormProps };

package/src/context/FormGroupContext.d.ts

@@ -1,30 +1,19 @@
-import { FormCore, TFormCore, TFormGroup, TFormValues, TMapper } from '@bolttech/form-engine-core';
-import { ElementType, PropsWithChildren, ReactElement } from 'react';
-type TFormContext = {
-    addFormWithIndex: (index: string) => void;
-    addForm: (payload: {
-        key: string;
-        formInstance: TFormCore;
-    }) => void;
-    getForm: (payload: {
-        key: string;
-    }) => FormCore | undefined;
-    removeForm: (payload: {
-        key: string;
-    }) => void;
-    formGroupInstance: TFormGroup;
-    mappers?: TMapper<ElementType>[];
-    printFormGroupInstance: () => void;
-    submitMultipleFormsByIndex: (indexes: string[]) => TFormValues;
-    debugMode: boolean;
-    active: boolean;
-};
-type TFormContextProvider = {
-    mappers?: TMapper<ElementType>[];
-    debugMode?: boolean;
-};
+import { PropsWithChildren, ReactElement } from 'react';
+import { TFormContext, TFormContextProvider } from './FormGroupContext.type';
 declare const FormGroupContext: import("react").Context<TFormContext>;
+/**
+ * context provider to wrap form-engine adapter elements
+ *
+ * @param {PropsWithChildren<TFormContextProvider>} param context parameters
+ * @returns {ReactElement}
+ */
 declare const FormGroupContextProvider: ({ children, mappers, debugMode, }: PropsWithChildren<TFormContextProvider>) => ReactElement;
-declare const useFormGroupContext: (props: TFormContextProvider) => TFormContext;
+/**
+ * FormGroup context hook to handle context or isolated context implementations
+ *
+ * @param {TFormContextProvider} props form group context parameters
+ * @returns {TFormContext}
+ */
+declare const useFormGroupContext: (props?: TFormContextProvider) => TFormContext;
 export { FormGroupContext, FormGroupContextProvider, useFormGroupContext };
 export type { TFormContext };

package/src/context/FormGroupContext.type.d.ts

@@ -0,0 +1,46 @@
+import { FormCore, TFormCore, TFormGroup, TFormValues, TMapper } from '@bolttech/form-engine-core';
+import { ElementType } from 'react';
+/**
+ * Represents the context for managing forms within a form group.
+ *
+ * @property {function(string): void} addFormWithIndex - Adds a form to the form group by its index.
+ * @property {function({ key: string, formInstance: TFormCore }): void} addForm - Adds a form to the form group using a payload containing the key and form instance.
+ * @property {function({ key: string }): (FormCore | undefined)} getForm - Retrieves a form from the form group using a payload containing the key.
+ * @property {function({ key: string }): void} removeForm - Removes a form from the form group using a payload containing the key.
+ * @property {TFormGroup} formGroupInstance - The instance of the form group.
+ * @property {TMapper<ElementType>[]} [mappers] - Optional array of mappers for elements.
+ * @property {function(): void} printFormGroupInstance - Prints the form group instance.
+ * @property {function(string[]): TFormValues} submitMultipleFormsByIndex - Submits multiple forms by their indexes and returns the form values.
+ * @property {boolean} debugMode - Indicates if debug mode is active.
+ * @property {boolean} active - Indicates if the form context is active.
+ */
+type TFormContext = {
+    addFormWithIndex: (index: string) => void;
+    addForm: (payload: {
+        key: string;
+        formInstance: TFormCore;
+    }) => void;
+    getForm: (payload: {
+        key: string;
+    }) => FormCore | undefined;
+    removeForm: (payload: {
+        key: string;
+    }) => void;
+    formGroupInstance: TFormGroup;
+    mappers?: TMapper<ElementType>[];
+    printFormGroupInstance: () => void;
+    submitMultipleFormsByIndex: <T>(indexes: string[]) => TFormValues<T>;
+    debugMode: boolean;
+    active: boolean;
+};
+/**
+ * Represents the props for a form context provider.
+ *
+ * @property {TMapper<ElementType>[]} [mappers] - Optional array of mappers for elements.
+ * @property {boolean} [debugMode] - Optional flag indicating if debug mode should be enabled.
+ */
+type TFormContextProvider = {
+    mappers?: TMapper<ElementType>[];
+    debugMode?: boolean;
+};
+export type { TFormContext, TFormContextProvider };

package/src/generators/formBuilder.d.ts

@@ -1,10 +1,25 @@
 import { ReactNode } from 'react';
 import { IFormField, IComponentSchema } from '@bolttech/form-engine-core';
+/**
+ * recursive function to transform form fields from a form instance into
+ * a react component tree
+ *
+ * @param {Map<string,IFormField>} param.fields form instance field Map
+ * @param {string} param.prevPath previous field path to track the tree branch creation
+ * @param {string} param.formIndex form index to aid field identification onto the FieldWrapper
+ * @returns {ReactNode}
+ */
 declare const BuildTree: ({ fields, prevPath, formIndex, }: {
     fields: Map<string, IFormField>;
     prevPath?: string | undefined;
     formIndex: string;
 }) => ReactNode;
+/**
+ * function to transform AsFormField elements onto a JSON schema
+ *
+ * @param param.children ReactNode children elements
+ * @returns {IComponentSchema[] | null | undefined}
+ */
 declare const BuildAsFormFieldTree: ({ children, }: {
     children?: ReactNode;
 }) => IComponentSchema[] | null | undefined;

package/src/helpers/helpers.d.ts

@@ -1,4 +1,7 @@
 import { TEvents } from '@bolttech/form-engine-core';
-import { eventProps } from '../types';
-declare const eventsMapping: Partial<Record<TEvents, eventProps>>;
+import { TEventProps } from '../types';
+/**
+ * events mapping to aid function callback binding
+ */
+declare const eventsMapping: Partial<Record<TEvents, TEventProps>>;
 export { eventsMapping };

package/src/hooks/useForm.d.ts

@@ -1,6 +1,6 @@
-import { TEventsCallbackProps } from '../types';
-import { TFieldEvent } from '@bolttech/form-engine-core';
-declare const useForm: ({ id, ...rest }: {
-    id: string;
-} & Partial<Record<import("../types").eventProps, ((payload: TFieldEvent) => void) | null | undefined>>) => void;
+import { TUseFormProps } from './useForm.type';
+/**
+ * Hook to register events callback functions
+ */
+declare const useForm: ({ id, ...rest }: TUseFormProps) => void;
 export default useForm;

package/src/hooks/useForm.type.d.ts

@@ -0,0 +1,12 @@
+import { TEventsCallbackProps } from '../types';
+/**
+ * Represents the properties for the useForm hook, including an ID and event callback properties.
+ *
+ * @property {string} id - The unique identifier for the form.
+ *
+ * @see {@link TEventsCallbackProps}
+ */
+type TUseFormProps = {
+    id: string;
+} & TEventsCallbackProps;
+export type { TUseFormProps };