@akad/form-builder 1.0.0

package/components/FormBuilder/hooks/useFormState.d.ts

@@ -0,0 +1,28 @@
+import { UseFormStateConfig, UseFormStateReturn } from '../FormBuilder.config';
+/**
+ * Hook for form state management without validation or parsing logic
+ * @description Manages form data state, dirty/touched tracking, and field updates with dot notation support for nested objects
+ * @param config UseFormStateConfig with initialData and deepEqual options
+ * @returns UseFormStateReturn with form state and manipulation functions
+ * @example
+ * ```tsx
+ * const state = useFormState({
+ *   initialData: { name: '', email: '' },
+ *   deepEqual: false
+ * });
+ *
+ * // Update fields
+ * state.setField('name', 'John');
+ * state.setField('user.address.street', '123 Main St'); // nested objects with dot notation
+ *
+ * // Check state
+ * console.log(state.isDirty); // true
+ * console.log(state.formData); // { name: 'John', user: { address: { street: '123 Main St' } } }
+ *
+ * // Clear or reset
+ * state.clearForm(); // Empty state
+ * state.resetForm(); // Back to initialData
+ * ```
+ */
+export declare const useFormState: (config?: UseFormStateConfig) => UseFormStateReturn;
+export default useFormState;

package/components/FormBuilder/hooks/useFormState.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/FormBuilder/hooks/useFormStepper.d.ts

@@ -0,0 +1,64 @@
+import { JSONSchema7 } from 'json-schema';
+import { useForm } from './useForm';
+/**
+ * Helper to create step-specific schema from fields
+ * Extracts only the fields needed for current step
+ * Supports nested fields with dot notation (e.g., 'insured.address.postCode')
+ */
+export declare const createStepSchema: (fields: string[], dataSchema: JSONSchema7) => JSONSchema7;
+/**
+ * Form stepper step configuration
+ */
+export interface FormStepperStep {
+    id: string;
+    title: string;
+    subtitle?: string;
+    icon?: string;
+    fields: string[];
+    schema: JSONSchema7;
+    uiSchema?: Record<string, unknown>;
+}
+/**
+ * Form stepper configuration
+ */
+export interface UseFormStepperConfig {
+    steps: FormStepperStep[];
+    dataSchema: JSONSchema7;
+    initialData?: Record<string, unknown>;
+    onSubmit?: (data: Record<string, unknown>) => void | Promise<void>;
+}
+/**
+ * Form stepper return type
+ */
+export interface UseFormStepperReturn {
+    currentStep: number;
+    currentStepConfig: FormStepperStep;
+    completedSteps: Set<number>;
+    form: ReturnType<typeof useForm>;
+    isStepValid: boolean;
+    validateStep: (stepIndex: number) => boolean;
+    goNext: () => void;
+    goPrev: () => void;
+    goTo: (stepIndex: number) => void;
+    canGoNext: boolean;
+    canGoPrev: boolean;
+    canGoTo: (stepIndex: number) => boolean;
+    isFirstStep: boolean;
+    isLastStep: boolean;
+    totalSteps: number;
+    progress: number;
+    submit: () => Promise<void>;
+    reset: () => void;
+    createStepSchema: (fields: string[], dataSchema: JSONSchema7) => JSONSchema7;
+}
+/**
+ * Hook for managing multi-step forms with DsStepper integration
+ *
+ * Simple, clean architecture:
+ * - No infinite loops
+ * - Inline validation
+ * - Direct state control
+ * - Works perfectly with DsStepper
+ */
+export declare const useFormStepper: (config: UseFormStepperConfig) => UseFormStepperReturn;
+export default useFormStepper;

package/components/FormBuilder/hooks/useFormStepper.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/FormBuilder/hooks/useFormValidation.d.ts

@@ -0,0 +1,7 @@
+import { UseFormValidationConfig, UseFormValidationReturn } from '../FormBuilder.config';
+/**
+ * Hook for form validation using JSON Schema and custom validators
+ * Implements two-layer validation system for optimal performance
+ */
+export declare const useFormValidation: (config: UseFormValidationConfig) => UseFormValidationReturn;
+export default useFormValidation;

package/components/FormBuilder/hooks/useFormValidation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/FormBuilder/index.d.ts

@@ -0,0 +1,27 @@
+import { default as FieldRenderer } from './components/FieldRenderer';
+import { GenericWrapper } from './components/GenericWrapper';
+import { default as RadioGroup } from './components/RadioGroup/RadioGroup';
+import { default as FormBuilderComponent } from './FormBuilder';
+import { default as useForm } from './hooks/useForm';
+import { default as useFormParser } from './hooks/useFormParser';
+import { default as useFormState } from './hooks/useFormState';
+import { default as useFormStepper } from './hooks/useFormStepper';
+import { default as useFormValidation } from './hooks/useFormValidation';
+import { resolveComponent } from './utils/componentRegistry';
+import { default as generateFieldsFromSchema, processWrapperChildren } from './utils/generateFieldsFromSchema';
+declare const FormBuilder: typeof FormBuilderComponent & {
+    useForm: typeof useForm;
+    useFormState: typeof useFormState;
+    useFormValidation: typeof useFormValidation;
+    useFormParser: typeof useFormParser;
+    useFormStepper: typeof useFormStepper;
+    generateFieldsFromSchema: typeof generateFieldsFromSchema;
+    processWrapperChildren: typeof processWrapperChildren;
+    resolveComponent: typeof resolveComponent;
+    FieldRenderer: typeof FieldRenderer;
+    GenericWrapper: typeof GenericWrapper;
+};
+export { FormBuilder, useForm, GenericWrapper, RadioGroup };
+export type { FormBuilderProps, UseFormConfig, UseFormReturn, FieldConfig, ComponentProps, UISchema, ValidationResult, FieldError, } from './FormBuilder.config';
+export type { GenericWrapperProps } from './components/GenericWrapper';
+export type { RadioGroupProps, RadioOption } from './components/RadioGroup';

package/components/FormBuilder/utils/ajv/formats.d.ts

@@ -0,0 +1,27 @@
+import { cnpjValidator, cpfCnpjValidator, cpfValidator, emailValidator, phoneBrValidator } from '@akad/helptils';
+export declare const RegularExpressions: {
+    'zip-code': {
+        type: string;
+        validate: string;
+    };
+    cnpj: {
+        type: string;
+        validate: typeof cnpjValidator;
+    };
+    email: {
+        type: string;
+        validate: typeof emailValidator;
+    };
+    'phone-br': {
+        type: string;
+        validate: typeof phoneBrValidator;
+    };
+    cpf: {
+        type: string;
+        validate: typeof cpfValidator;
+    };
+    'cpf-cnpj': {
+        type: string;
+        validate: typeof cpfCnpjValidator;
+    };
+};

package/components/FormBuilder/utils/ajv/formats.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/FormBuilder/utils/ajv/instance.d.ts

@@ -0,0 +1,2 @@
+import { default as Ajv } from 'ajv';
+export declare const createAjvInstance: () => Ajv;

package/components/FormBuilder/utils/ajv/instance.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/FormBuilder/utils/componentDetection.d.ts

@@ -0,0 +1,24 @@
+import { ComponentType, ComponentDetectionRule } from '../FormBuilder.config';
+/**
+ * Schema-to-Component detection mapping
+ * @description Maps JSON Schema types to appropriate UI components with conditions
+ */
+export declare const SCHEMA_COMPONENT_MAP: Record<string, ComponentDetectionRule>;
+/**
+ * Detect appropriate UI component based on JSON Schema properties
+ * @description Analyzes JSON Schema field properties to determine the best UI component
+ * @param fieldSchema JSON Schema field definition with type and constraints
+ * @returns Object with detected ComponentType and suggested props
+ * @example
+ * ```tsx
+ * detectFieldComponent({ type: 'string', format: 'email' })
+ * // returns { component: ComponentType.Input, props: { type: 'email' } }
+ *
+ * detectFieldComponent({ type: 'string', 'x-options': [...] })
+ * // returns { component: ComponentType.Select, props: {} }
+ * ```
+ */
+export declare const detectFieldComponent: (fieldSchema: Record<string, unknown>) => {
+    component: ComponentType;
+    props: Record<string, unknown>;
+};

package/components/FormBuilder/utils/componentDetection.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/FormBuilder/utils/componentRegistry.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+import { ComponentRegistry, ComponentType, ComponentProps } from '../FormBuilder.config';
+/**
+ * Resolve component from registry
+ */
+export declare const resolveComponent: (componentName: ComponentType, customComponents?: ComponentRegistry) => React.ComponentType<ComponentProps>;
+declare const _default: {
+    resolveComponent: (componentName: ComponentType, customComponents?: ComponentRegistry) => React.ComponentType<ComponentProps>;
+};
+export default _default;

package/components/FormBuilder/utils/componentRegistry.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/FormBuilder/utils/facade/AddressFormLegacy.d.ts

@@ -0,0 +1,20 @@
+import { default as React } from 'react';
+import { ComponentProps } from '../../FormBuilder.config';
+import { FBForm } from './makeFullFormHookFacade';
+interface AddressFormLegacyProps extends ComponentProps {
+    __form: FBForm;
+    __schema: Record<string, unknown>;
+    schemaPrefix?: string;
+    title?: string;
+    getAddress?: (postCode: string) => Promise<unknown>;
+    address?: Record<string, unknown>;
+    isLoading?: boolean;
+    isError?: boolean;
+    disabled?: boolean;
+}
+/**
+ * Legacy AddressForm wrapper using FormHook Facade
+ * Allows AddressForm (which expects legacy formHook interface) to work with FormBuilder
+ */
+export declare const AddressFormLegacy: React.FC<AddressFormLegacyProps>;
+export default AddressFormLegacy;

package/components/FormBuilder/utils/facade/AddressFormLegacy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/FormBuilder/utils/facade/PaymentOptionsLegacy.d.ts

@@ -0,0 +1,22 @@
+import { default as React } from 'react';
+import { ComponentProps } from '../../FormBuilder.config';
+import { FBForm } from './makeFullFormHookFacade';
+interface PaymentOptionsLegacyProps extends ComponentProps {
+    __form: FBForm;
+    __schema: Record<string, unknown>;
+    paymentSummary?: Array<{
+        paymentType: string;
+        installments: Array<{
+            quantity: number;
+            amount: number;
+        }>;
+    }>;
+    showDecimals?: boolean;
+    currencyType?: string;
+}
+/**
+ * Legacy PaymentOptions wrapper using FormHook Facade
+ * Allows PaymentOptions (which expects legacy formHook interface) to work with FormBuilder
+ */
+export declare const PaymentOptionsLegacy: React.FC<PaymentOptionsLegacyProps>;
+export default PaymentOptionsLegacy;

package/components/FormBuilder/utils/facade/PaymentOptionsLegacy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/FormBuilder/utils/facade/index.d.ts

@@ -0,0 +1,6 @@
+export { useMakeFullFormHookFacade, makeFullFormHookFacade, } from './makeFullFormHookFacade';
+export { AddressFormLegacy } from './AddressFormLegacy';
+export { PaymentOptionsLegacy } from './PaymentOptionsLegacy';
+export { useLegacyFormHook } from './useLegacyFormHook';
+export type { FBForm, MakeFacadeOptions } from './makeFullFormHookFacade';
+export type { LegacyFormHook } from './useLegacyFormHook';

package/components/FormBuilder/utils/facade/makeFullFormHookFacade.d.ts

@@ -0,0 +1,111 @@
+import { default as React } from 'react';
+type FieldError = {
+    message?: string;
+    type?: string;
+};
+export type FBForm = {
+    data: Record<string, unknown>;
+    setField: (path: string, value: unknown) => void;
+    setData: (data: Record<string, unknown>) => void;
+    clear?: () => void;
+    reset?: () => void;
+    validate?: () => Promise<{
+        isValid: boolean;
+        errors?: Record<string, FieldError>;
+    }>;
+    validateField: (name: string) => {
+        isValid: boolean;
+        error?: FieldError;
+    };
+    onBlur: (name: string) => void;
+    errors: Record<string, FieldError>;
+    isDirty?: boolean;
+    touched?: Record<string, boolean>;
+};
+export type MakeFacadeOptions = {
+    ajvInstance?: unknown;
+    requireTouchedForStatus?: boolean;
+};
+export declare function useMakeFullFormHookFacade({ form, schema, options, }: {
+    form: FBForm;
+    schema: Record<string, unknown>;
+    options?: MakeFacadeOptions;
+}): {
+    getFormSchema: () => Record<string, unknown>;
+    getFormData: Record<string, unknown>;
+    getInputSchema: (name: string) => Record<string, unknown>;
+    getInputValidateStatus: (name: string) => string;
+    getInputValidateMessage: (name: string) => string | undefined;
+    validateForm: ({ touched }?: {
+        touched?: boolean;
+    }) => {
+        status: boolean;
+        fields: Record<string, {
+            status: boolean;
+            touched?: boolean;
+            message?: string;
+        }>;
+    };
+    validateFormSchema: (schemaId: string, _schemaData: Record<string, unknown>, opts?: {
+        touched?: boolean;
+    }) => {
+        status: boolean;
+        fields: Record<string, {
+            status: boolean;
+            touched?: boolean;
+            message?: string;
+        }>;
+    };
+    handleCustomValue: (name: string, value: unknown) => void;
+    clearFormDataKey: () => void;
+    handleFormInput: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    register: (name: string) => {
+        checked: boolean;
+        onChangeHandler: (e: React.ChangeEvent<HTMLInputElement>) => void;
+        onBlurHandler: () => {
+            isValid: boolean;
+            error?: FieldError;
+        };
+        onFocusHandler: () => Set<string>;
+        name: string;
+        value: unknown;
+        label: {};
+        status: string;
+        feedback: string | undefined;
+        type: string | undefined;
+        ref: (el: HTMLElement | null) => void;
+    } | {
+        options: {};
+        onChangeHandler: (e: React.ChangeEvent<HTMLSelectElement>) => void;
+        name: string;
+        value: unknown;
+        label: {};
+        status: string;
+        feedback: string | undefined;
+        type: string | undefined;
+        ref: (el: HTMLElement | null) => void;
+    } | {
+        onChangeHandler: (e: React.ChangeEvent<HTMLInputElement> | unknown) => void;
+        onBlurHandler: () => void;
+        onFocusHandler: () => void;
+        name: string;
+        value: unknown;
+        label: {};
+        status: string;
+        feedback: string | undefined;
+        type: string | undefined;
+        ref: (el: HTMLElement | null) => void;
+    };
+    getFormEvent: Record<string, unknown>;
+    setFormData: (events: Record<string, unknown>) => void;
+    handleFormFlagFields: (key: string, value: unknown) => void;
+    getFormFlagFields: Record<string, unknown>;
+    parseFormToObject: () => {
+        toJson: () => string;
+    };
+    clearFormData: () => void;
+    isFormDirty: boolean;
+    ajv: unknown;
+};
+export default useMakeFullFormHookFacade;
+export declare const makeFullFormHookFacade: typeof useMakeFullFormHookFacade;

package/components/FormBuilder/utils/facade/makeFullFormHookFacade.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/FormBuilder/utils/facade/useLegacyFormHook.d.ts

@@ -0,0 +1,45 @@
+import { ReactNode, ChangeEvent } from 'react';
+import { FBForm, MakeFacadeOptions } from './makeFullFormHookFacade';
+/**
+ * Legacy FormHook interface used by older components (AddressForm, PaymentOptions)
+ * This interface is kept for backwards compatibility with components written before FormBuilder
+ */
+export interface LegacyFormHook {
+    register: (name: string) => Record<string, ReactNode>;
+    getInputSchema: (name: string) => Record<string, string>;
+    getFormData: Record<string, unknown>;
+    handleCustomValue: (name: string, value: unknown) => void;
+    clearFormDataKey: (name: string) => void;
+    handleFormInput: (e: ChangeEvent<HTMLInputElement>) => void;
+    validateFormSchema: (name: string, value: unknown) => void;
+}
+/**
+ * Composition hook that creates a legacy-compatible FormHook from FormBuilder's form/schema
+ *
+ * **Purpose:**
+ * - Bridges the gap between new FormBuilder components and legacy components
+ * - Provides a React-idiomatic way to adapt the facade to legacy format
+ * - Eliminates code duplication across legacy wrapper components
+ *
+ * **Usage Example:**
+ * ```typescript
+ * export const AddressFormLegacy = (props) => {
+ *   const { __form: form, __schema: schema } = props;
+ *   const formHook = useLegacyFormHook({ form, schema });
+ *
+ *   return <AddressForm formHook={formHook} {...otherProps} />;
+ * };
+ * ```
+ *
+ * @param params - Configuration object
+ * @param params.form - FormBuilder's FBForm instance
+ * @param params.schema - JSON Schema for validation
+ * @param params.options - Optional facade configuration
+ * @returns Legacy-compatible FormHook object
+ */
+export declare function useLegacyFormHook({ form, schema, options, }: {
+    form: FBForm;
+    schema: Record<string, unknown>;
+    options?: MakeFacadeOptions;
+}): LegacyFormHook;
+export default useLegacyFormHook;

package/components/FormBuilder/utils/facade/useLegacyFormHook.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/FormBuilder/utils/fieldExtractors.d.ts

@@ -0,0 +1,68 @@
+import { ValidationRules, FieldOption, UISchemaField } from '../FormBuilder.config';
+/**
+ * Extract validation rules from JSON Schema field
+ * @description Converts JSON Schema validation properties into ValidationRules format
+ * @param fieldSchema JSON Schema field definition with validation constraints
+ * @returns ValidationRules object with extracted validation rules
+ * @example
+ * ```tsx
+ * extractValidationRules({
+ *   type: 'string',
+ *   minLength: 2,
+ *   maxLength: 50,
+ *   format: 'email'
+ * })
+ * // returns { type: 'string', minLength: 2, maxLength: 50, format: 'email' }
+ * ```
+ */
+export declare const extractValidationRules: (fieldSchema: Record<string, unknown>) => ValidationRules;
+/**
+ * Extract field options from schema
+ * @description Extracts dropdown/select options from x-options or enum properties
+ * @param fieldSchema JSON Schema field definition that may contain options
+ * @returns Array of FieldOption objects or undefined if no options found
+ * @example
+ * ```tsx
+ * extractFieldOptions({
+ *   'x-options': [
+ *     { value: 'BR', label: 'Brazil' },
+ *     { value: 'US', label: 'United States' }
+ *   ]
+ * })
+ * // returns [{ value: 'BR', label: 'Brazil' }, { value: 'US', label: 'United States' }]
+ *
+ * extractFieldOptions({ enum: ['small', 'medium', 'large'] })
+ * // returns [{ value: 'small', label: 'Small' }, { value: 'medium', label: 'Medium' }, ...]
+ * ```
+ */
+export declare const extractFieldOptions: (fieldSchema: Record<string, unknown>) => FieldOption[] | undefined;
+/**
+ * Extract field label from schema and UI config
+ */
+export declare const extractFieldLabel: (fieldName: string, fieldSchema: Record<string, unknown>, uiConfig: UISchemaField) => string;
+/**
+ * Extract field placeholder from schema and UI config
+ */
+export declare const extractFieldPlaceholder: (fieldSchema: Record<string, unknown>, uiConfig: UISchemaField) => string | undefined;
+/**
+ * Extract field help text from schema and UI config
+ */
+export declare const extractFieldHelp: (fieldSchema: Record<string, unknown>, uiConfig: UISchemaField) => string | undefined;
+/**
+ * Generate component props from schema and UI config
+ * @description Combines schema-derived props with UI config props for component rendering
+ * @param fieldSchema JSON Schema field definition with constraints
+ * @param uiConfig UI Schema field configuration with ui:props
+ * @param detectedProps Props detected from component detection logic
+ * @returns Combined props object for component rendering
+ * @example
+ * ```tsx
+ * generateComponentProps(
+ *   { type: 'string', format: 'email', minLength: 5 },
+ *   { 'ui:props': { label: 'Email', size: 'large' } },
+ *   { type: 'email' }
+ * )
+ * // returns { type: 'email', inputMode: 'email', minLength: 5, label: 'Email', size: 'large' }
+ * ```
+ */
+export declare const generateComponentProps: (fieldSchema: Record<string, unknown>, uiConfig: UISchemaField, detectedProps: Record<string, unknown>) => Record<string, unknown>;

package/components/FormBuilder/utils/fieldExtractors.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/FormBuilder/utils/generateFieldsFromSchema.d.ts

@@ -0,0 +1,67 @@
+import { JSONSchema7 } from 'json-schema';
+import { FieldConfig, UISchema, UISchemaField } from '../FormBuilder.config';
+/**
+ * Generate field configuration from JSON Schema field definition
+ * @description Creates complete FieldConfig by combining JSON Schema, UI Schema, and detected component info
+ * @param fieldName Name of the field in the schema
+ * @param fieldSchema JSON Schema field definition with validation and type info
+ * @param rootSchema Complete JSON Schema for required field detection (used for flat schemas)
+ * @param uiConfig UI Schema field configuration for layout and styling
+ * @param isRequiredOverride Optional override for required status (used for nested schemas)
+ * @returns Complete FieldConfig ready for rendering
+ * @example
+ * ```tsx
+ * generateFieldConfig(
+ *   'email',
+ *   { type: 'string', format: 'email', minLength: 5 },
+ *   { required: ['email'] },
+ *   { 'ui:component': 'Input', 'ui:props': { label: 'Email Address' } }
+ * )
+ * // returns FieldConfig with component: Input, validation rules, required: true, etc.
+ * ```
+ */
+export declare const generateFieldConfig: (fieldName: string, fieldSchema: Record<string, unknown>, rootSchema: JSONSchema7, uiConfig?: UISchemaField, isRequiredOverride?: boolean) => FieldConfig;
+/**
+ * Process children fields for GenericWrapper component
+ * @description Converts children object from UI Schema into FieldConfig array for wrapper components
+ * Supports BOTH flat dot notation and nested object notation in children
+ * @param children Children configuration from UI Schema ui:props.children
+ * @param schema Complete JSON Schema to extract field definitions and x-options
+ * @returns Record of FieldConfig objects for child fields
+ */
+export declare const processWrapperChildren: (children: Record<string, unknown>, schema: JSONSchema7) => Record<string, FieldConfig>;
+/**
+ * Main function to generate field configurations from JSON Schema and UI Schema
+ * @description Transforms JSON Schema and UI Schema into array of FieldConfig objects for FormBuilder rendering
+ * @param schema JSONSchema7 with field definitions, validation rules, and required fields
+ * @param uiSchema UI Schema with layout, component, and styling configuration
+ * @param stepId Optional step identifier for multi-step forms (WizardBuilder integration)
+ * @returns Array of FieldConfig objects sorted by ui:order, ready for FormBuilder rendering
+ * @example
+ * ```tsx
+ * const fields = generateFieldsFromSchema(
+ *   {
+ *     type: 'object',
+ *     properties: {
+ *       name: { type: 'string', minLength: 2 },
+ *       email: { type: 'string', format: 'email' }
+ *     },
+ *     required: ['name', 'email']
+ *   },
+ *   {
+ *     contact: {
+ *       'ui:layout': 'grid',
+ *       name: { 'ui:component': 'Input', 'ui:props': { label: 'Full Name' } },
+ *       email: { 'ui:component': 'Input', 'ui:props': { label: 'Email' } }
+ *     }
+ *   },
+ *   'contact'
+ * );
+ * // returns [FieldConfig, FieldConfig] with detected components and validation
+ * ```
+ */
+export declare const generateFieldsFromSchema: (schema: JSONSchema7, uiSchema?: UISchema, stepId?: string) => FieldConfig[];
+export default generateFieldsFromSchema;
+export { resolveUIConfig, flattenSchemaProperties, flattenUISchemaChildren, } from './schemaUtils';
+export { detectFieldComponent, SCHEMA_COMPONENT_MAP, } from './componentDetection';
+export { extractValidationRules, extractFieldOptions, extractFieldLabel, extractFieldPlaceholder, extractFieldHelp, generateComponentProps, } from './fieldExtractors';

package/components/FormBuilder/utils/generateFieldsFromSchema.test.d.ts

@@ -0,0 +1 @@
+export {};

package/components/FormBuilder/utils/objectAccess.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Get a nested value from an object using dot notation
+ * @param obj The object to navigate
+ * @param path The dot notation path to the value
+ * @returns The value at the path
+ */
+export declare const getNestedValue: (obj: Record<string, unknown>, path: string) => unknown;

package/components/FormBuilder/utils/objectAccess.test.d.ts

@@ -0,0 +1 @@
+export {};