mastra 0.1.57-alpha.90 → 0.1.57-unstable.100

package/dist/shared/components/dynamic-form/fields/array-field.js

@@ -0,0 +1,12 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Plus, X } from 'lucide-react';
+import { useFieldArray } from 'react-hook-form';
+import { Button } from '../../ui/button';
+export function ArrayField({ name, control, renderField }) {
+    const { fields, append, remove } = useFieldArray({
+        control,
+        name,
+    });
+    return (_jsxs("div", { className: "space-y-2", children: [fields.map((field, index) => (_jsxs("div", { className: "relative flex items-center gap-2", children: [renderField({ fieldName: `${name}.${index}`, index }), _jsx(Button, { type: "button", variant: "ghost", size: "icon", className: "absolute -right-2 -top-2", onClick: () => remove(index), children: _jsx(X, { className: "h-4 w-4" }) })] }, field.id))), _jsxs(Button, { type: "button", variant: "outline", size: "sm", className: "w-full", onClick: () => append({}), children: [_jsx(Plus, { className: "mr-2 h-4 w-4" }), "Add Item"] })] }));
+}

package/dist/shared/components/dynamic-form/fields/boolean-field.d.ts

@@ -0,0 +1,11 @@
+import { Control } from 'react-hook-form';
+interface BooleanFieldProps {
+    name: string;
+    control: Control<any>;
+    handleFieldChange?: (props: {
+        key: string;
+        value: boolean;
+    }) => void;
+}
+export declare function BooleanField({ name, control, handleFieldChange }: BooleanFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/components/dynamic-form/fields/boolean-field.js

@@ -0,0 +1,10 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Controller } from 'react-hook-form';
+import { Switch } from '../../ui/switch';
+export function BooleanField({ name, control, handleFieldChange }) {
+    return (_jsx(Controller, { name: name, control: control, render: ({ field }) => (_jsx(Switch, { checked: field.value, onCheckedChange: checked => {
+                field.onChange(checked);
+                handleFieldChange?.({ key: name, value: checked });
+            } })) }));
+}

package/dist/shared/components/dynamic-form/fields/creatable-field.d.ts

@@ -0,0 +1,16 @@
+import { Control } from 'react-hook-form';
+interface CreatableFieldProps {
+    name: string;
+    control: Control<any>;
+    options?: {
+        label: string;
+        value: string;
+    }[];
+    handleFieldChange?: (props: {
+        key: string;
+        value: string[];
+    }) => void;
+    placeholder?: string;
+}
+export declare function CreatableField({ name, control, options, handleFieldChange, placeholder }: CreatableFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/components/dynamic-form/fields/creatable-field.js

@@ -0,0 +1,33 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Plus, X } from 'lucide-react';
+import * as React from 'react';
+import { Controller } from 'react-hook-form';
+import { Badge } from '../../ui/badge';
+import { Button } from '../../ui/button';
+import { Command, CommandInput, CommandList, CommandGroup, CommandItem } from '../../ui/command';
+import { Popover, PopoverContent, PopoverTrigger } from '../../ui/popover';
+export function CreatableField({ name, control, options = [], handleFieldChange, placeholder }) {
+    const [openPopover, setOpenPopover] = React.useState(false);
+    const [inputValue, setInputValue] = React.useState('');
+    return (_jsx(Controller, { name: name, control: control, render: ({ field }) => {
+            const selectedValues = field.value || [];
+            const removeValue = (valueToRemove) => {
+                const newValues = selectedValues.filter((v) => v !== valueToRemove);
+                field.onChange(newValues);
+                handleFieldChange?.({ key: name, value: newValues });
+            };
+            const addValue = (value) => {
+                if (!value)
+                    return;
+                const newValues = [...selectedValues, value];
+                field.onChange(newValues);
+                handleFieldChange?.({ key: name, value: newValues });
+                setInputValue('');
+                setOpenPopover(false);
+            };
+            return (_jsxs("div", { className: "space-y-2", children: [_jsx("div", { className: "flex flex-wrap gap-2", children: selectedValues.map((value) => (_jsxs(Badge, { className: "flex items-center gap-1", children: [value, _jsx(Button, { variant: "ghost", size: "icon", className: "h-4 w-4 p-0", onClick: () => removeValue(value), children: _jsx(X, { className: "h-3 w-3" }) })] }, value))) }), _jsxs(Popover, { open: openPopover, onOpenChange: setOpenPopover, children: [_jsx(PopoverTrigger, { asChild: true, children: _jsxs(Button, { variant: "outline", size: "sm", className: "w-full justify-start", children: [_jsx(Plus, { className: "mr-2 h-4 w-4" }), placeholder || 'Add item'] }) }), _jsx(PopoverContent, { className: "p-0", align: "start", children: _jsxs(Command, { children: [_jsx(CommandInput, { placeholder: "Enter value...", value: inputValue, onValueChange: setInputValue }), _jsx(CommandList, { children: _jsxs(CommandGroup, { children: [options
+                                                        .filter(opt => !selectedValues.includes(opt.value))
+                                                        .map(option => (_jsx(CommandItem, { onSelect: () => addValue(option.value), children: option.label }, option.value))), inputValue && (_jsxs(CommandItem, { onSelect: () => addValue(inputValue), children: ["Create \"", inputValue, "\""] }))] }) })] }) })] })] }));
+        } }));
+}

package/dist/shared/components/dynamic-form/fields/date-field.d.ts

@@ -0,0 +1,11 @@
+import { Control } from 'react-hook-form';
+interface DateFieldProps {
+    name: string;
+    control: Control<any>;
+    handleFieldChange?: (props: {
+        key: string;
+        value: Date | null | undefined;
+    }) => void;
+}
+export declare function DateField({ name, control, handleFieldChange }: DateFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/components/dynamic-form/fields/date-field.js

@@ -0,0 +1,10 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Controller } from 'react-hook-form';
+import { DatePicker } from '../../ui/date-picker';
+export function DateField({ name, control, handleFieldChange }) {
+    return (_jsx(Controller, { name: name, control: control, render: ({ field }) => (_jsx(DatePicker, { value: field.value, setValue: date => {
+                field.onChange(date);
+                handleFieldChange?.({ key: name, value: date });
+            } })) }));
+}

package/dist/shared/components/dynamic-form/fields/enum-field.d.ts

@@ -0,0 +1,15 @@
+import { Control } from 'react-hook-form';
+interface EnumFieldProps {
+    name: string;
+    control: Control<any>;
+    options: {
+        label: string;
+        value: string;
+    }[];
+    handleFieldChange?: (props: {
+        key: string;
+        value: string;
+    }) => void;
+}
+export declare function EnumField({ name, control, options, handleFieldChange }: EnumFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/components/dynamic-form/fields/enum-field.js

@@ -0,0 +1,10 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Controller } from 'react-hook-form';
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '../../ui/select';
+export function EnumField({ name, control, options, handleFieldChange }) {
+    return (_jsx(Controller, { name: name, control: control, render: ({ field }) => (_jsxs(Select, { value: field.value, onValueChange: value => {
+                field.onChange(value);
+                handleFieldChange?.({ key: name, value });
+            }, children: [_jsx(SelectTrigger, { children: _jsx(SelectValue, { placeholder: "Select an option" }) }), _jsx(SelectContent, { children: options.map(option => (_jsx(SelectItem, { value: option.value, children: option.label }, option.value))) })] })) }));
+}

package/dist/shared/components/dynamic-form/fields/index.d.ts

@@ -0,0 +1,10 @@
+export { ArrayField } from './array-field';
+export { BooleanField } from './boolean-field';
+export { CreatableField } from './creatable-field';
+export { DateField } from './date-field';
+export { EnumField } from './enum-field';
+export { StringField } from './string-field';
+export { UnionField } from './union-field';
+export { ObjectField } from './object-field';
+export { NumberField } from './number-field';
+export { RecordField } from './record-field';

package/dist/shared/components/dynamic-form/fields/index.js

@@ -0,0 +1,10 @@
+export { ArrayField } from './array-field';
+export { BooleanField } from './boolean-field';
+export { CreatableField } from './creatable-field';
+export { DateField } from './date-field';
+export { EnumField } from './enum-field';
+export { StringField } from './string-field';
+export { UnionField } from './union-field';
+export { ObjectField } from './object-field';
+export { NumberField } from './number-field';
+export { RecordField } from './record-field';

package/dist/shared/components/dynamic-form/fields/number-field.d.ts

@@ -0,0 +1,11 @@
+import { Control } from 'react-hook-form';
+interface NumberFieldProps {
+    name: string;
+    control: Control<any>;
+    handleFieldChange?: (props: {
+        key: string;
+        value: number;
+    }) => void;
+}
+export declare function NumberField({ name, control, handleFieldChange }: NumberFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/components/dynamic-form/fields/number-field.js

@@ -0,0 +1,11 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Controller } from 'react-hook-form';
+import { Input } from '../../ui/input';
+export function NumberField({ name, control, handleFieldChange }) {
+    return (_jsx(Controller, { name: name, control: control, render: ({ field }) => (_jsx(Input, { ...field, type: "number", onChange: e => {
+                const value = e.target.value === '' ? undefined : Number(e.target.value);
+                field.onChange(value);
+                handleFieldChange?.({ key: name, value: value });
+            } })) }));
+}

package/dist/shared/components/dynamic-form/fields/object-field.d.ts

@@ -0,0 +1,27 @@
+import * as React from 'react';
+import { ZodSchema } from 'zod';
+interface ObjectFieldProps {
+    renderDynamicForm: (props: {
+        schema: ZodSchema;
+        handleFieldChange: (field: string, value: any) => void;
+        control: any;
+        formValues: Record<string, any>;
+        errors: Record<string, any>;
+        parentField: string;
+        action?: any;
+        isOptional?: boolean;
+        depth?: number;
+    }) => React.ReactNode;
+    schema: ZodSchema;
+    handleFieldChange: (field: string, value: any) => void;
+    control: any;
+    formValues: Record<string, any>;
+    errors: Record<string, any>;
+    parentField: string;
+    action?: any;
+    isArray?: boolean;
+    isOptional?: boolean;
+    depth?: number;
+}
+export declare function ObjectField({ renderDynamicForm, schema, handleFieldChange, control, formValues, errors, parentField, action, isArray, isOptional, depth, }: ObjectFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/components/dynamic-form/fields/object-field.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { XIcon } from 'lucide-react';
+import { useFieldArray } from 'react-hook-form';
+import { ZodArray } from 'zod';
+import { toTitleCase } from '../../../lib/string';
+import { Button } from '../../ui/button';
+import { Label } from '../../ui/label';
+import { Text } from '../../ui/text';
+import { getFormConfigTypesFromSchemaDef } from '../schema';
+export function ObjectField({ renderDynamicForm, schema, handleFieldChange, control, formValues, errors, parentField, action, isArray = false, isOptional = false, depth, }) {
+    const fieldConfig = getFormConfigTypesFromSchemaDef({ schema, isOptional });
+    const { fields, append, remove } = useFieldArray({
+        control,
+        name: parentField,
+    });
+    function handleAddForm() {
+        append({});
+    }
+    return (_jsxs("div", { children: [_jsxs(Label, { className: "flex gap-0.5 capitalize mb-2", htmlFor: parentField, "aria-required": !fieldConfig.isOptional, children: [!fieldConfig?.isOptional && _jsx("span", { className: "text-red-500", children: "*" }), _jsx(Text, { variant: "secondary", className: "text-mastra-el-3", size: "xs", children: toTitleCase(parentField) })] }), isArray ? (_jsxs(_Fragment, { children: [_jsx("div", { className: "flex flex-col gap-4", children: fields.map((field, index) => (_jsxs("div", { className: "ring-1 ring-white/10 p-2 rounded-md relative", children: [_jsx(Button, { type: "button", variant: 'ghost', size: 'icon', onClick: () => remove(index), className: "absolute top-0 right-0", children: _jsx(XIcon, { className: "text-icon h-3.5 w-3.5" }) }), renderDynamicForm({
+                                    schema: schema instanceof ZodArray ? schema.element : schema,
+                                    handleFieldChange,
+                                    control,
+                                    formValues,
+                                    errors,
+                                    parentField: `${parentField}.${index}`,
+                                    action,
+                                    isOptional,
+                                    depth,
+                                })] }, field.id))) }), _jsx("div", { className: "flex flex-col gap-4", children: _jsxs(Button, { type: "button", variant: 'outline', className: "w-full text-xs h-9", onClick: handleAddForm, children: ["Add ", toTitleCase(parentField.split('.').pop() || '')] }) })] })) : (_jsx("div", { className: "ring-1 ring-white/10 p-2 rounded-md relative", children: renderDynamicForm({
+                    schema,
+                    handleFieldChange,
+                    control,
+                    formValues,
+                    errors,
+                    parentField,
+                    action,
+                    isOptional,
+                    depth,
+                }) }))] }));
+}

package/dist/shared/components/dynamic-form/fields/record-field.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import { Control } from 'react-hook-form';
+import { ZodSchema } from 'zod';
+interface RecordFieldProps {
+    name: string;
+    control: Control<any>;
+    innerSchema?: ZodSchema;
+    renderField: (props: {
+        fieldName: string;
+        index: number;
+    }) => React.ReactNode;
+    handleFieldChange?: (props: {
+        key: string;
+        value: Record<string, any>;
+    }) => void;
+}
+export declare function RecordField({ name, control, renderField }: RecordFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/components/dynamic-form/fields/record-field.js

@@ -0,0 +1,13 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Plus, X } from 'lucide-react';
+import { useFieldArray } from 'react-hook-form';
+import { Button } from '../../ui/button';
+import { Input } from '../../ui/input';
+export function RecordField({ name, control, renderField }) {
+    const { fields, append, remove } = useFieldArray({
+        control,
+        name,
+    });
+    return (_jsxs("div", { className: "space-y-3", children: [fields.map((field, index) => (_jsxs("div", { className: "relative space-y-2 rounded-lg border p-4", children: [_jsx(Button, { type: "button", variant: "ghost", size: "icon", className: "absolute right-2 top-2", onClick: () => remove(index), children: _jsx(X, { className: "h-4 w-4" }) }), _jsxs("div", { className: "space-y-2", children: [_jsx(Input, { placeholder: "Key", ...control.register(`${name}.${index}.key`) }), renderField({ fieldName: `${name}.${index}.value`, index })] })] }, field.id))), _jsxs(Button, { type: "button", variant: "outline", size: "sm", className: "w-full", onClick: () => append({ key: '', value: '' }), children: [_jsx(Plus, { className: "mr-2 h-4 w-4" }), "Add Key-Value Pair"] })] }));
+}

package/dist/shared/components/dynamic-form/fields/string-field.d.ts

@@ -0,0 +1,13 @@
+import { Control } from 'react-hook-form';
+interface StringFieldProps {
+    name: string;
+    control: Control<any>;
+    handleFieldChange?: (props: {
+        key: string;
+        value: any;
+    }) => void;
+    isMultiline?: boolean;
+    placeholder?: string;
+}
+export declare function StringField({ name, control, handleFieldChange, isMultiline, placeholder }: StringFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/components/dynamic-form/fields/string-field.js

@@ -0,0 +1,12 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Controller } from 'react-hook-form';
+import { Input } from '../../ui/input';
+import { Textarea } from '../../ui/textarea';
+export function StringField({ name, control, handleFieldChange, isMultiline, placeholder }) {
+    const Component = isMultiline ? Textarea : Input;
+    return (_jsx(Controller, { name: name, control: control, render: ({ field }) => (_jsx(Component, { ...field, placeholder: placeholder, onChange: e => {
+                field.onChange(e);
+                handleFieldChange?.({ key: name, value: e.target.value });
+            } })) }));
+}

package/dist/shared/components/dynamic-form/fields/union-field.d.ts

@@ -0,0 +1,28 @@
+import * as React from 'react';
+import { ZodUnion } from 'zod';
+interface UnionComponentProps {
+    renderDynamicForm: (props: {
+        schema: ZodUnion<any>;
+        handleFieldChange: (field: string, value: any) => void;
+        control: any;
+        formValues: Record<string, any>;
+        errors: Record<string, any>;
+        parentField: string;
+        action?: any;
+        isOptional?: boolean;
+        isNullable?: boolean;
+        depth?: number;
+    }) => React.ReactNode;
+    schema: ZodUnion<any>;
+    handleFieldChange: (field: string, value: any) => void;
+    control: any;
+    formValues: Record<string, any>;
+    errors: Record<string, any>;
+    parentField: string;
+    action?: any;
+    isOptional?: boolean;
+    isNullable?: boolean;
+    depth?: number;
+}
+export declare function UnionField({ renderDynamicForm, schema, handleFieldChange, control, formValues, errors, parentField, action, isOptional, isNullable, depth, }: UnionComponentProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/components/dynamic-form/fields/union-field.js

@@ -0,0 +1,27 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as React from 'react';
+import { ZodUnion } from 'zod';
+import { toTitleCase } from '../../../lib/string';
+import { Label } from '../../ui/label';
+import { Text } from '../../ui/text';
+import { getFormConfigTypesFromSchemaDef } from '../schema';
+export function UnionField({ renderDynamicForm, schema, handleFieldChange, control, formValues, errors, parentField, action, isOptional = false, isNullable = false, depth, }) {
+    const fieldConfig = getFormConfigTypesFromSchemaDef({ schema, isOptional });
+    if (schema instanceof ZodUnion) {
+        const schemaOptions = schema.options;
+        return (_jsxs("div", { children: [_jsxs(Label, { className: "flex gap-0.5 capitalize mb-2", htmlFor: parentField, "aria-required": !fieldConfig.isOptional, children: [!fieldConfig?.isOptional && _jsx("span", { className: "text-red-500", children: "*" }), _jsx(Text, { variant: "secondary", className: "text-mastra-el-3", size: "xs", children: toTitleCase(parentField) })] }), _jsx("div", { className: "flex flex-col gap-4", children: schemaOptions.map((schemaOption, index) => (_jsxs(React.Fragment, { children: [index >= 1 && (_jsx(Text, { variant: "secondary", className: "text-mastra-el-3 text-center", size: "xs", children: "or" })), _jsx("div", { className: "ring-1 ring-white/10 p-2 rounded-md relative", children: renderDynamicForm({
+                                    schema: schemaOption,
+                                    handleFieldChange,
+                                    control,
+                                    formValues,
+                                    errors,
+                                    parentField,
+                                    action,
+                                    isOptional,
+                                    isNullable,
+                                    depth,
+                                }) })] }, index))) })] }));
+    }
+    return null;
+}

package/dist/shared/components/dynamic-form/index.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+interface DynamicFormProps<T extends z.ZodSchema> {
+    schema: T;
+    onSubmit: (values: z.infer<T>) => void | Promise<void>;
+    onChange?: (values: Partial<z.infer<T>>) => void;
+    isSubmitLoading?: boolean;
+}
+export declare function DynamicForm<T extends z.ZodSchema>({ schema, onSubmit, onChange, isSubmitLoading, }: DynamicFormProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/shared/components/dynamic-form/index.js

@@ -0,0 +1,50 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { zodResolver } from '@hookform/resolvers/zod';
+import { Loader2 } from 'lucide-react';
+import * as React from 'react';
+import { useForm } from 'react-hook-form';
+import { z } from 'zod';
+import { Button } from '../ui/button';
+import { ScrollArea } from '../ui/scroll-area';
+import { customZodUnionResolver } from './resolvers';
+import { resolveSchema } from './schema-resolver';
+export function DynamicForm({ schema, onSubmit, onChange, isSubmitLoading, }) {
+    const schemaTypeName = schema?._def?.typeName;
+    const discriminatedUnionSchemaOptions = schema?._def?.options;
+    const discriminatedUnionSchemaDiscriminator = schema?._def?.discriminator;
+    const form = useForm({
+        resolver: schemaTypeName === 'ZodDiscriminatedUnion'
+            ? customZodUnionResolver(schema, discriminatedUnionSchemaDiscriminator)
+            : zodResolver(schema),
+    });
+    const { control, handleSubmit, watch } = form;
+    const formValues = form.watch();
+    const discriminatorValue = discriminatedUnionSchemaDiscriminator
+        ? watch(discriminatedUnionSchemaDiscriminator)
+        : undefined;
+    const resolvedSchema = schemaTypeName === 'ZodDiscriminatedUnion'
+        ? discriminatedUnionSchemaOptions?.find((option) => option?.shape?.[discriminatedUnionSchemaDiscriminator]?._def?.value === discriminatorValue) || z.object({ [discriminatedUnionSchemaDiscriminator]: z.string() })
+        : schema;
+    React.useEffect(() => {
+        onChange?.(formValues);
+    }, [formValues, onChange]);
+    function handleFieldChange({ key, value }) {
+        if (key === discriminatedUnionSchemaDiscriminator) {
+            form.setValue(key, value);
+            onChange?.({ ...formValues, [key]: value });
+        }
+        else {
+            form.setValue(key, value);
+            onChange?.({ ...formValues, [key]: value });
+        }
+    }
+    return (_jsx(ScrollArea, { className: "h-full w-full", children: _jsxs("form", { onSubmit: handleSubmit(onSubmit), className: "flex flex-col gap-4 p-4", children: [resolveSchema({
+                    schema: resolvedSchema,
+                    parentField: '',
+                    control,
+                    formValues,
+                    errors: form.formState.errors,
+                    handleFieldChange,
+                }), _jsx(Button, { disabled: isSubmitLoading, type: "submit", children: isSubmitLoading ? _jsx(Loader2, { className: "h-4 w-4 animate-spin" }) : 'Submit' })] }) }));
+}

package/dist/shared/components/dynamic-form/resolvers/index.d.ts

@@ -0,0 +1,3 @@
+import { Resolver } from 'react-hook-form';
+import { z } from 'zod';
+export declare const customZodUnionResolver: (schemaUnion: z.ZodTypeAny, discriminator: string) => Resolver<any>;

package/dist/shared/components/dynamic-form/resolvers/index.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { transformToNestObject } from '../utils';
+export const customZodUnionResolver = (schemaUnion, discriminator) => {
+    return async (values) => {
+        //get schema based on discriminator
+        const schema = schemaUnion?._def?.options?.find((option) => option?.shape?.[discriminator]?._def?.value === values[discriminator]) || z.object({ [discriminator]: z.string() });
+        // Filter out keys that are not in the schema
+        const filteredValues = Object.fromEntries(Object.entries(values).filter(([key]) => schema?.shape?.[key]));
+        const result = schema.safeParse(filteredValues);
+        if (result.success) {
+            return { values: result.data, errors: {} };
+        }
+        else {
+            const errors = transformToNestObject(result.error);
+            return { values: {}, errors };
+        }
+    };
+};

package/dist/shared/components/dynamic-form/schema-resolver.d.ts

@@ -0,0 +1,20 @@
+import { Control, FieldErrors } from 'react-hook-form';
+import { z } from 'zod';
+interface ResolveSchemaProps {
+    schema: z.ZodSchema;
+    parentField: string;
+    control: Control<any>;
+    formValues: any;
+    errors: FieldErrors;
+    handleFieldChange: (props: {
+        key: string | number | symbol;
+        value: any;
+    }) => void;
+    isArray?: boolean;
+    isOptional?: boolean;
+    isNullable?: boolean;
+}
+export declare function resolveSchema({ schema, parentField, control, formValues, errors, handleFieldChange, isOptional, isNullable, depth, }: ResolveSchemaProps & {
+    depth?: number;
+}): import("react/jsx-runtime").JSX.Element | import("react/jsx-runtime").JSX.Element[];
+export {};

package/dist/shared/components/dynamic-form/schema-resolver.js

@@ -0,0 +1,97 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { z } from 'zod';
+import { getDefaultFieldMap } from './default-field-map';
+import { ObjectField, UnionField } from './fields';
+import { schemaToFormFieldRenderer } from './schema';
+function adaptHandleFieldChange(handler) {
+    return (field, value) => handler({ key: field, value });
+}
+export function resolveSchema({ schema, parentField, control, formValues, errors, handleFieldChange, isOptional = false, isNullable = false, depth = 0, }) {
+    if (depth > 10) {
+        console.warn('Maximum schema resolution depth reached. Possible circular reference.');
+        return null;
+    }
+    if (schema instanceof z.ZodObject) {
+        return Object.entries(schema.shape).map(([field, fieldSchema]) => {
+            const currentField = parentField ? `${parentField}.${field}` : field;
+            return resolveSchemaComponent({
+                schema: fieldSchema,
+                parentField: currentField,
+                control,
+                formValues,
+                errors,
+                handleFieldChange,
+                isOptional,
+                isNullable,
+            });
+        });
+    }
+    return resolveSchemaComponent({
+        schema,
+        parentField,
+        control,
+        formValues,
+        errors,
+        handleFieldChange,
+        isOptional,
+        isNullable,
+    });
+}
+function resolveSchemaComponent({ schema, parentField, control, formValues, errors, handleFieldChange, isOptional = false, isNullable = false, }) {
+    if (schema instanceof z.ZodDefault)
+        return null;
+    if (schema instanceof z.ZodOptional) {
+        return resolveSchemaComponent({
+            schema: schema._def.innerType,
+            parentField,
+            control,
+            formValues,
+            errors,
+            handleFieldChange,
+            isOptional: true,
+            isNullable,
+        });
+    }
+    if (schema instanceof z.ZodObject) {
+        return (_jsx("div", { className: "flex flex-col gap-8 py-8", children: _jsx(ObjectField, { schema: schema, control: control, parentField: parentField, handleFieldChange: (field, value) => handleFieldChange({ key: field, value }), formValues: formValues, errors: errors, isOptional: isOptional, renderDynamicForm: props => resolveSchema({ ...props, handleFieldChange }) }) }, parentField));
+    }
+    if (schema instanceof z.ZodUnion) {
+        if (schema.options.some((s) => s instanceof z.ZodNull)) {
+            const nonNullSchema = schema.options.find((s) => !(s instanceof z.ZodNull));
+            return resolveSchemaComponent({
+                schema: z.optional(nonNullSchema),
+                parentField,
+                control,
+                formValues,
+                errors,
+                handleFieldChange,
+                isNullable: true,
+            });
+        }
+        return (_jsx(UnionField, { schema: schema, control: control, parentField: parentField, handleFieldChange: adaptHandleFieldChange(handleFieldChange), formValues: formValues, errors: errors, isOptional: isOptional, isNullable: isNullable, renderDynamicForm: props => resolveSchema({
+                ...props,
+                handleFieldChange: props => handleFieldChange(props),
+            }) }));
+    }
+    if (schema instanceof z.ZodArray) {
+        return resolveSchemaComponent({
+            schema: schema.element,
+            parentField,
+            control,
+            formValues,
+            errors,
+            handleFieldChange,
+            isOptional,
+            isNullable,
+        });
+    }
+    return (_jsx("div", { children: schemaToFormFieldRenderer({
+            schema,
+            schemaField: parentField,
+            control,
+            values: formValues,
+            errors,
+            renderFieldMap: getDefaultFieldMap(),
+            onFieldChange: handleFieldChange,
+        }) }, parentField));
+}