@form-instant/react-resolver-zod 1.18.12 → 2.0.0-rc.1

package/dist/components/FormInstantProvider.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { zodResolverProps } from 'types';
+export declare const ZodResolverContext: import("react").Context<any>;
+export declare const FormInstantProvider: FCC<{
+    schema: zodResolverProps;
+}>;
+/**
+ * Hook to get a specific field by name from the schema
+ */
+export declare const useFields: <Sc extends Record<string, any>>(key: keyof Sc) => any;

package/dist/components/SchemaMapper.d.ts

@@ -0,0 +1,24 @@
+import { SchemaMapperProps, ElementProps } from '../types';
+/**
+ * Main component for mapping Zod schemas to React components
+ * Provides an agnostic way to map schema fields to components
+ */
+export declare function SchemaMapper({ schema, componentMapping, defaultComponent, transformProps, children, }: SchemaMapperProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Hook to use schema mapping context
+ */
+export declare function useSchemaMappingContext(): {
+    metadata: any;
+    mappingConfig: any;
+};
+/**
+ * Component for rendering a specific field by name
+ * Maintains backward compatibility with the old Element component
+ */
+export declare function FormInstantElement<S extends Record<string, any>>({ name }: ElementProps<S>): import("react/jsx-runtime").JSX.Element | null;
+/**
+ * Component for rendering a field by path
+ */
+export declare function SchemaField({ path }: {
+    path: string;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/examples/completeExample.d.ts

@@ -0,0 +1,6 @@
+export declare function UserFormExample1(): import("react/jsx-runtime").JSX.Element;
+export declare function UserFormExample2(): import("react/jsx-runtime").JSX.Element;
+export declare function UserFormExample3(): import("react/jsx-runtime").JSX.Element;
+export declare function CustomUserForm(): import("react/jsx-runtime").JSX.Element;
+export declare function UserFormWithValidation(): import("react/jsx-runtime").JSX.Element;
+export declare const styles = "\n.user-form {\n    max-width: 600px;\n    margin: 0 auto;\n    padding: 20px;\n}\n\n.form-section {\n    margin-bottom: 30px;\n    padding: 20px;\n    border: 1px solid #e0e0e0;\n    border-radius: 8px;\n}\n\n.form-section h3 {\n    margin-top: 0;\n    color: #333;\n    border-bottom: 2px solid #007bff;\n    padding-bottom: 10px;\n}\n\n.form-field {\n    margin-bottom: 20px;\n}\n\n.form-label {\n    display: block;\n    margin-bottom: 5px;\n    font-weight: 600;\n    color: #333;\n}\n\n.required {\n    color: #dc3545;\n    margin-left: 4px;\n}\n\n.form-input,\n.form-select,\n.form-textarea {\n    width: 100%;\n    padding: 10px;\n    border: 1px solid #ddd;\n    border-radius: 4px;\n    font-size: 14px;\n}\n\n.form-input:focus,\n.form-select:focus,\n.form-textarea:focus {\n    outline: none;\n    border-color: #007bff;\n    box-shadow: 0 0 0 2px rgba(0, 123, 255, 0.25);\n}\n\n.checkbox {\n    display: flex;\n    align-items: flex-start;\n}\n\n.checkbox-label {\n    display: flex;\n    align-items: center;\n    cursor: pointer;\n}\n\n.form-checkbox {\n    margin-right: 8px;\n}\n\n.checkbox-text {\n    font-weight: 500;\n}\n\n.field-description {\n    margin-top: 5px;\n    font-size: 12px;\n    color: #666;\n}\n\n.validation-message {\n    margin-top: 5px;\n    font-size: 12px;\n    color: #dc3545;\n}\n\n.async-validation {\n    margin-top: 5px;\n    font-size: 12px;\n    color: #007bff;\n}\n\n.field-info {\n    margin-top: 5px;\n    font-size: 12px;\n    color: #28a745;\n    background: #f8f9fa;\n    padding: 5px;\n    border-radius: 3px;\n}\n\n.field-debug {\n    margin-top: 5px;\n    padding: 5px;\n    background: #f8f9fa;\n    border-radius: 3px;\n    font-family: monospace;\n}\n\n.form-actions {\n    margin-top: 30px;\n    text-align: center;\n}\n\n.submit-button {\n    background: #007bff;\n    color: white;\n    border: none;\n    padding: 12px 30px;\n    border-radius: 4px;\n    font-size: 16px;\n    cursor: pointer;\n    transition: background-color 0.2s;\n}\n\n.submit-button:hover {\n    background: #0056b3;\n}\n";

package/dist/examples/fieldConfigExample.d.ts

@@ -0,0 +1,158 @@
+import { BaseFieldConfigOptions } from '../utils/zodExtensions';
+interface UserFieldConfig extends BaseFieldConfigOptions {
+    dp?: Record<string, any>;
+    userSpecific?: {
+        minAge?: number;
+        maxAge?: number;
+    };
+}
+export declare function createUserSchema(): import("zod").ZodObject<{
+    name: import("zod").ZodString;
+    email: import("zod").ZodString;
+    age: import("zod").ZodOptional<import("zod").ZodNumber>;
+    isActive: import("zod").ZodBoolean;
+    role: import("zod").ZodEnum<{
+        [x: string]: string;
+    }>;
+}, import("zod/v4/core/schemas.cjs").$strip> & {
+    fieldConfig: <TConfig = BaseFieldConfigOptions>(config: import("../utils/zodExtensions").FieldConfigOptions<TConfig>) => import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        email: import("zod").ZodString;
+        age: import("zod").ZodOptional<import("zod").ZodNumber>;
+        isActive: import("zod").ZodBoolean;
+        role: import("zod").ZodEnum<{
+            [x: string]: string;
+        }>;
+    }, import("zod/v4/core/schemas.cjs").$strip>;
+};
+export declare function createProfileSchema(): import("zod").ZodObject<{
+    user: import("zod").ZodObject<{
+        profile: import("zod").ZodObject<{
+            email: import("zod").ZodString;
+            name: import("zod").ZodString;
+        }, import("zod/v4/core/schemas.cjs").$strip> & {
+            fieldConfig: <TConfig = BaseFieldConfigOptions>(config: import("../utils/zodExtensions").FieldConfigOptions<TConfig>) => import("zod").ZodObject<{
+                email: import("zod").ZodString;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core/schemas.cjs").$strip>;
+        };
+    }, import("zod/v4/core/schemas.cjs").$strip> & {
+        fieldConfig: <TConfig_1 = BaseFieldConfigOptions>(config: import("../utils/zodExtensions").FieldConfigOptions<TConfig_1>) => import("zod").ZodObject<{
+            profile: import("zod").ZodObject<{
+                email: import("zod").ZodString;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core/schemas.cjs").$strip> & {
+                fieldConfig: <TConfig = BaseFieldConfigOptions>(config: import("../utils/zodExtensions").FieldConfigOptions<TConfig>) => import("zod").ZodObject<{
+                    email: import("zod").ZodString;
+                    name: import("zod").ZodString;
+                }, import("zod/v4/core/schemas.cjs").$strip>;
+            };
+        }, import("zod/v4/core/schemas.cjs").$strip>;
+    };
+}, import("zod/v4/core/schemas.cjs").$strip> & {
+    fieldConfig: <TConfig_2 = BaseFieldConfigOptions>(config: import("../utils/zodExtensions").FieldConfigOptions<TConfig_2>) => import("zod").ZodObject<{
+        user: import("zod").ZodObject<{
+            profile: import("zod").ZodObject<{
+                email: import("zod").ZodString;
+                name: import("zod").ZodString;
+            }, import("zod/v4/core/schemas.cjs").$strip> & {
+                fieldConfig: <TConfig = BaseFieldConfigOptions>(config: import("../utils/zodExtensions").FieldConfigOptions<TConfig>) => import("zod").ZodObject<{
+                    email: import("zod").ZodString;
+                    name: import("zod").ZodString;
+                }, import("zod/v4/core/schemas.cjs").$strip>;
+            };
+        }, import("zod/v4/core/schemas.cjs").$strip> & {
+            fieldConfig: <TConfig_1 = BaseFieldConfigOptions>(config: import("../utils/zodExtensions").FieldConfigOptions<TConfig_1>) => import("zod").ZodObject<{
+                profile: import("zod").ZodObject<{
+                    email: import("zod").ZodString;
+                    name: import("zod").ZodString;
+                }, import("zod/v4/core/schemas.cjs").$strip> & {
+                    fieldConfig: <TConfig = BaseFieldConfigOptions>(config: import("../utils/zodExtensions").FieldConfigOptions<TConfig>) => import("zod").ZodObject<{
+                        email: import("zod").ZodString;
+                        name: import("zod").ZodString;
+                    }, import("zod/v4/core/schemas.cjs").$strip>;
+                };
+            }, import("zod/v4/core/schemas.cjs").$strip>;
+        };
+    }, import("zod/v4/core/schemas.cjs").$strip>;
+};
+export declare function createFormSchema(): import("zod").ZodObject<{
+    step1: import("zod").ZodObject<{
+        firstName: import("zod").ZodString;
+        lastName: import("zod").ZodString;
+    }, import("zod/v4/core/schemas.cjs").$strip> & {
+        fieldConfig: <TConfig = BaseFieldConfigOptions>(config: import("../utils/zodExtensions").FieldConfigOptions<TConfig>) => import("zod").ZodObject<{
+            firstName: import("zod").ZodString;
+            lastName: import("zod").ZodString;
+        }, import("zod/v4/core/schemas.cjs").$strip>;
+    };
+    step2: import("zod").ZodObject<{
+        email: import("zod").ZodString;
+    }, import("zod/v4/core/schemas.cjs").$strip> & {
+        fieldConfig: <TConfig_1 = BaseFieldConfigOptions>(config: import("../utils/zodExtensions").FieldConfigOptions<TConfig_1>) => import("zod").ZodObject<{
+            email: import("zod").ZodString;
+        }, import("zod/v4/core/schemas.cjs").$strip>;
+    };
+}, import("zod/v4/core/schemas.cjs").$strip> & {
+    fieldConfig: <TConfig_2 = BaseFieldConfigOptions>(config: import("../utils/zodExtensions").FieldConfigOptions<TConfig_2>) => import("zod").ZodObject<{
+        step1: import("zod").ZodObject<{
+            firstName: import("zod").ZodString;
+            lastName: import("zod").ZodString;
+        }, import("zod/v4/core/schemas.cjs").$strip> & {
+            fieldConfig: <TConfig = BaseFieldConfigOptions>(config: import("../utils/zodExtensions").FieldConfigOptions<TConfig>) => import("zod").ZodObject<{
+                firstName: import("zod").ZodString;
+                lastName: import("zod").ZodString;
+            }, import("zod/v4/core/schemas.cjs").$strip>;
+        };
+        step2: import("zod").ZodObject<{
+            email: import("zod").ZodString;
+        }, import("zod/v4/core/schemas.cjs").$strip> & {
+            fieldConfig: <TConfig_1 = BaseFieldConfigOptions>(config: import("../utils/zodExtensions").FieldConfigOptions<TConfig_1>) => import("zod").ZodObject<{
+                email: import("zod").ZodString;
+            }, import("zod/v4/core/schemas.cjs").$strip>;
+        };
+    }, import("zod/v4/core/schemas.cjs").$strip>;
+};
+export declare function createUsersArraySchema(): import("zod").ZodObject<{
+    users: import("zod").ZodArray<import("zod").ZodObject<{
+        name: import("zod").ZodString;
+        email: import("zod").ZodString;
+    }, import("zod/v4/core/schemas.cjs").$strip> & {
+        fieldConfig: <TConfig = BaseFieldConfigOptions>(config: import("../utils/zodExtensions").FieldConfigOptions<TConfig>) => import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            email: import("zod").ZodString;
+        }, import("zod/v4/core/schemas.cjs").$strip>;
+    }>;
+}, import("zod/v4/core/schemas.cjs").$strip> & {
+    fieldConfig: <TConfig_1 = BaseFieldConfigOptions>(config: import("../utils/zodExtensions").FieldConfigOptions<TConfig_1>) => import("zod").ZodObject<{
+        users: import("zod").ZodArray<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            email: import("zod").ZodString;
+        }, import("zod/v4/core/schemas.cjs").$strip> & {
+            fieldConfig: <TConfig = BaseFieldConfigOptions>(config: import("../utils/zodExtensions").FieldConfigOptions<TConfig>) => import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                email: import("zod").ZodString;
+            }, import("zod/v4/core/schemas.cjs").$strip>;
+        }>;
+    }, import("zod/v4/core/schemas.cjs").$strip>;
+};
+export declare function getFieldConfiguration(): {
+    fieldType: "text";
+} & {
+    label: string;
+    placeholder?: string | undefined;
+    maxLength?: number | undefined;
+} & UserFieldConfig;
+export declare function legacyCompatibilityExample(): import("zod").ZodObject<{
+    name: import("zod").ZodString & {
+        fieldConfig: <TConfig = BaseFieldConfigOptions>(config: import("../utils/zodExtensions").FieldConfigOptions<TConfig>) => import("zod").ZodString;
+    };
+}, import("zod/v4/core/schemas.cjs").$strip>;
+export declare function defaultTypeExample(): import("zod").ZodObject<{
+    simpleField: import("zod").ZodString;
+}, import("zod/v4/core/schemas.cjs").$strip> & {
+    fieldConfig: <TConfig = BaseFieldConfigOptions>(config: import("../utils/zodExtensions").FieldConfigOptions<TConfig>) => import("zod").ZodObject<{
+        simpleField: import("zod").ZodString;
+    }, import("zod/v4/core/schemas.cjs").$strip>;
+};
+export {};

package/dist/examples/formInstantExample.d.ts

@@ -0,0 +1,6 @@
+export declare function UserFormExample1(): import("react/jsx-runtime").JSX.Element;
+export declare function UserFormExample2(): import("react/jsx-runtime").JSX.Element;
+export declare function UserFormExample3(): import("react/jsx-runtime").JSX.Element;
+export declare function UserFormWithHooks(): import("react/jsx-runtime").JSX.Element;
+export declare function UserFormWithValidation(): import("react/jsx-runtime").JSX.Element;
+export declare const styles = "\n.user-form {\n    max-width: 600px;\n    margin: 0 auto;\n    padding: 20px;\n}\n\n.form-section {\n    margin-bottom: 30px;\n    padding: 20px;\n    border: 1px solid #e0e0e0;\n    border-radius: 8px;\n}\n\n.form-section h3 {\n    margin-top: 0;\n    color: #333;\n    border-bottom: 2px solid #007bff;\n    padding-bottom: 10px;\n}\n\n.form-field {\n    margin-bottom: 20px;\n}\n\n.form-label {\n    display: block;\n    margin-bottom: 5px;\n    font-weight: 600;\n    color: #333;\n}\n\n.required {\n    color: #dc3545;\n    margin-left: 4px;\n}\n\n.form-input,\n.form-select,\n.form-textarea {\n    width: 100%;\n    padding: 10px;\n    border: 1px solid #ddd;\n    border-radius: 4px;\n    font-size: 14px;\n}\n\n.form-input:focus,\n.form-select:focus,\n.form-textarea:focus {\n    outline: none;\n    border-color: #007bff;\n    box-shadow: 0 0 0 2px rgba(0, 123, 255, 0.25);\n}\n\n.checkbox {\n    display: flex;\n    align-items: flex-start;\n}\n\n.checkbox-label {\n    display: flex;\n    align-items: center;\n    cursor: pointer;\n}\n\n.form-checkbox {\n    margin-right: 8px;\n}\n\n.checkbox-text {\n    font-weight: 500;\n}\n\n.field-description {\n    margin-top: 5px;\n    font-size: 12px;\n    color: #666;\n}\n\n.validation-message {\n    margin-top: 5px;\n    font-size: 12px;\n    color: #dc3545;\n}\n\n.async-validation {\n    margin-top: 5px;\n    font-size: 12px;\n    color: #007bff;\n}\n\n.field-info {\n    margin-top: 5px;\n    font-size: 12px;\n    color: #28a745;\n    background: #f8f9fa;\n    padding: 5px;\n    border-radius: 3px;\n}\n\n.form-actions {\n    margin-top: 30px;\n    text-align: center;\n}\n\n.submit-button {\n    background: #007bff;\n    color: white;\n    border: none;\n    padding: 12px 30px;\n    border-radius: 4px;\n    font-size: 16px;\n    cursor: pointer;\n    transition: background-color 0.2s;\n}\n\n.submit-button:hover {\n    background: #0056b3;\n}\n\n.form-data-display {\n    margin-bottom: 30px;\n    padding: 20px;\n    background: #f8f9fa;\n    border-radius: 8px;\n}\n\n.data-section {\n    margin-bottom: 20px;\n}\n\n.data-section h5 {\n    margin-bottom: 10px;\n    color: #333;\n}\n\n.data-section pre {\n    background: #fff;\n    padding: 10px;\n    border-radius: 4px;\n    border: 1px solid #ddd;\n    font-size: 12px;\n    overflow-x: auto;\n}\n";

package/dist/examples/legacyCompatibility.d.ts

@@ -0,0 +1,30 @@
+export declare function createLegacyCompatibleSchema(): import("zod").ZodObject<{
+    name: import("zod").ZodString & {
+        fieldConfig: <TConfig = import("../utils/zodExtensions").BaseFieldConfigOptions>(config: import("../utils/zodExtensions").FieldConfigOptions<TConfig>) => import("zod").ZodString;
+    };
+    email: import("zod").ZodString & {
+        fieldConfig: <TConfig = import("../utils/zodExtensions").BaseFieldConfigOptions>(config: import("../utils/zodExtensions").FieldConfigOptions<TConfig>) => import("zod").ZodString;
+    };
+    age: import("zod").ZodOptional<import("zod").ZodNumber & {
+        fieldConfig: <TConfig_1 = import("../utils/zodExtensions").BaseFieldConfigOptions>(config: import("../utils/zodExtensions").FieldConfigOptions<TConfig_1>) => import("zod").ZodNumber;
+    }>;
+}, import("zod/v4/core/schemas.cjs").$strip>;
+export declare function useLegacySchema(): any;
+export declare function migrationExample(): {
+    oldSchema: import("zod").ZodObject<{
+        name: import("zod").ZodString & {
+            fieldConfig: <TConfig = import("../utils/zodExtensions").BaseFieldConfigOptions>(config: import("../utils/zodExtensions").FieldConfigOptions<TConfig>) => import("zod").ZodString;
+        };
+    }, import("zod/v4/core/schemas.cjs").$strip>;
+    newSchema: import("zod").ZodObject<{
+        name: import("zod").ZodString & {
+            fieldConfig: <TConfig = import("../utils/zodExtensions").BaseFieldConfigOptions>(config: import("../utils/zodExtensions").FieldConfigOptions<TConfig>) => import("zod").ZodString;
+        };
+    }, import("zod/v4/core/schemas.cjs").$strip> & {
+        fieldConfig: <TConfig_1 = import("../utils/zodExtensions").BaseFieldConfigOptions>(config: import("../utils/zodExtensions").FieldConfigOptions<TConfig_1>) => import("zod").ZodObject<{
+            name: import("zod").ZodString & {
+                fieldConfig: <TConfig = import("../utils/zodExtensions").BaseFieldConfigOptions>(config: import("../utils/zodExtensions").FieldConfigOptions<TConfig>) => import("zod").ZodString;
+            };
+        }, import("zod/v4/core/schemas.cjs").$strip>;
+    };
+};

package/dist/hooks/useSchemaMapping.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+import { ZodSchema, ComponentMapping, SchemaMappingResult } from '../types';
+/**
+ * Main hook for schema mapping functionality
+ * Provides schema metadata and mapping configuration for component mapping
+ */
+export declare function useSchemaMapping(schema: ZodSchema, componentMapping: ComponentMapping, options?: {
+    defaultComponent?: React.ComponentType<any>;
+    transformProps?: (props: any) => any;
+}): SchemaMappingResult;
+/**
+ * Hook for getting field information by path
+ */
+export declare function useFieldByPath(schema: ZodSchema, path: string): any;
+/**
+ * Hook for getting all available paths in a schema
+ */
+export declare function useSchemaPaths(schema: ZodSchema): any;
+/**
+ * Hook for checking if a path exists in a schema
+ */
+export declare function useHasPath(schema: ZodSchema, path: string): any;

package/dist/hooks/useSchemaMetadata.d.ts

@@ -0,0 +1,26 @@
+import { ZodSchema, FieldMetadata, SchemaMetadataResult } from '../types';
+/**
+ * Hook for schema metadata functionality
+ * Provides utilities for extracting and working with schema metadata
+ */
+export declare function useSchemaMetadata(schema: ZodSchema): SchemaMetadataResult;
+/**
+ * Hook for getting field metadata by name
+ */
+export declare function useFieldMetadata(schema: ZodSchema, fieldName: string): any;
+/**
+ * Hook for getting all field metadata
+ */
+export declare function useAllFields(schema: ZodSchema): Record<string, any>;
+/**
+ * Hook for getting schema structure
+ */
+export declare function useSchemaStructure(schema: ZodSchema): any;
+/**
+ * Hook for getting required fields
+ */
+export declare function useRequiredFields(schema: ZodSchema): Record<string, FieldMetadata>;
+/**
+ * Hook for getting optional fields
+ */
+export declare function useOptionalFields(schema: ZodSchema): Record<string, FieldMetadata>;

package/dist/hooks/useSchemaNavigation.d.ts

@@ -0,0 +1,18 @@
+import { ZodSchema, SchemaPath, FieldMetadata, SchemaNavigationResult } from '../types';
+/**
+ * Hook for schema navigation functionality
+ * Provides utilities for navigating through schema structures using dot notation paths
+ */
+export declare function useSchemaNavigation(schema: ZodSchema): SchemaNavigationResult;
+/**
+ * Hook for getting a specific field by path
+ */
+export declare function useField(schema: ZodSchema, path: SchemaPath): FieldMetadata | null;
+/**
+ * Hook for getting all paths in a schema
+ */
+export declare function usePaths(schema: ZodSchema): string[];
+/**
+ * Hook for checking if a path exists
+ */
+export declare function usePathExists(schema: ZodSchema, path: SchemaPath): boolean;

package/dist/index.d.ts

@@ -1,6 +1,5 @@
-export * from './context';
-export * from './element';
-export * from './funcs';
-export * from './provider';
-export * from './type';
-export * from './useSchema';
+export { FormInstantProvider, useFields } from './components/FormInstantProvider';
+export { FormInstantElement } from './components/FormInstantElement';
+export * from './types';
+export * from './utils/schemaParser';
+export * from './utils/zodExtensions';

package/dist/index.js

@@ -1,8 +1,3 @@
+import{createContext as N,useContext as z}from"react";import{z as Y}from"zod";function T(B){return B._zod?.def?.type||"unknown"}function F(B){let J=B?._fieldConfig;if(!J)return;return J}function E(B){let J={},_=[],w={};function A(U){if(U instanceof Y.ZodObject)return U.shape;if(U instanceof Y.ZodDiscriminatedUnion){let K=U.options;if(K.length>0)return A(K[0])}return{}}function L(U,K,R="",H=w){let V=F(K),q=R?`${R}.${U}`:U,P=V?.fieldType||T(K),v=K instanceof Y.ZodOptional,Z=K instanceof Y.ZodDefault,y=!v&&!Z,O=void 0;if(Z)try{let Q=K.safeParse(void 0);if(Q.success)O=Q.data}catch{}else try{let Q=K.safeParse(void 0);if(Q.success)O=Q.data}catch{}let x=(()=>{if(K instanceof Y.ZodEnum)return K.options.map((Q)=>[String(Q),String(Q)]);if(K.constructor.name==="ZodNativeEnum")return K.options.map(($)=>[String($),String($)]);return[]})(),I={name:{current:U,history:q},fieldType:P,required:y,default:O,fieldConfig:V,options:x};if(J[q]=I,_.push(q),H[U]=I,K instanceof Y.ZodObject){let Q=K.shape,$={};H[U]=$,Object.keys(Q).forEach((G)=>{L(G,Q[G],q,$)})}if(K instanceof Y.ZodArray){let Q=K.element;if(Q instanceof Y.ZodObject){let $={};H[U]=$;let G=Q.shape;Object.keys(G).forEach((M)=>{L(M,G[M],`${q}[0]`,$)})}}}let D=A(B);return Object.keys(D).forEach((U)=>{L(U,D[U])}),{fields:J}}function d(B){return T(B)}function f(B){let J=B instanceof Y.ZodOptional,_=B instanceof Y.ZodDefault;return!J&&!_}function n(B){try{let J=B.safeParse(void 0);return J.success?J.data:void 0}catch{return}}import{jsx as S}from"react/jsx-runtime";var b=N(null),g=({children:B,schema:J})=>{return S(b.Provider,{value:J,children:B})},k=(B)=>{let J=z(b);if(!J)throw new Error("useFields must be used within FormInstantProvider");let{fields:_}=E(J);return _[B]};import{ElementMapping as j}from"@form-instant/react-input-mapping";import{useId as p}from"react";import{jsx as W,Fragment as C}from"react/jsx-runtime";var u=({name:B})=>{let J=k(B),_=p();if(!["object"].includes(J.fieldType))return W(j,{formProps:J});return W(C,{children:Object.values(J.schema||{}).map((w)=>{return W(C,{children:W(j,{formProps:w})},`${_}-${w.name?.history||""}`)})})};import{z as X}from"zod";function o(){let B=Object.getPrototypeOf(X.string());return Object.defineProperty(B,"fieldConfig",{value:function(w){return this._fieldConfig=w,this},writable:!0,configurable:!0}),{...X,...{object:(w)=>{let A=X.object(w);return Object.assign(A,{fieldConfig:(L)=>{return A._fieldConfig=L,A}})},array:(w)=>{let A=X.array(w);return Object.assign(A,{fieldConfig:(L)=>{return A._fieldConfig=L,A}})},string:()=>{let w=X.string();return Object.assign(w,{fieldConfig:(A)=>{return w._fieldConfig=A,w}})},email:()=>{let w=X.string();return Object.assign(w,{fieldConfig:(A)=>{return w._fieldConfig=A,w}})},number:()=>{let w=X.number();return Object.assign(w,{fieldConfig:(A)=>{return w._fieldConfig=A,w}})},boolean:()=>{let w=X.boolean();return Object.assign(w,{fieldConfig:(A)=>{return w._fieldConfig=A,w}})},date:()=>{let w=X.date();return Object.assign(w,{fieldConfig:(A)=>{return w._fieldConfig=A,w}})},enum:(w)=>{let A=X.enum(w);return Object.assign(A,{fieldConfig:(L)=>{return A._fieldConfig=L,A}})},union:(w)=>{let A=X.union(w);return Object.assign(A,{fieldConfig:(L)=>{return A._fieldConfig=L,A}})},optional:(w)=>{let A=X.optional(w);if(w.fieldConfig)Object.assign(A,{fieldConfig:w.fieldConfig,_fieldConfig:w._fieldConfig});else Object.assign(A,{fieldConfig:(L)=>{return A._fieldConfig=L,A}});return A},nullable:(w)=>{let A=X.nullable(w);if(w.fieldConfig)Object.assign(A,{fieldConfig:w.fieldConfig,_fieldConfig:w._fieldConfig});else Object.assign(A,{fieldConfig:(L)=>{return A._fieldConfig=L,A}});return A}}}}var Jw=o();function Kw(B){return B._fieldConfig}function Lw(B,J){return B._fieldConfig=J,B}export{Jw as zExtended,Jw as z,k as useFields,Lw as setFieldConfig,E as parseSchema,f as isFieldRequired,d as getFieldType,Kw as getFieldConfig,n as getDefaultValue,o as extendZodWithFieldConfig,g as FormInstantProvider,u as FormInstantElement};
 
-'use strict'
-
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./react-resolver-zod.cjs.production.min.js')
-} else {
-  module.exports = require('./react-resolver-zod.cjs.development.js')
-}
+//# debugId=14376D9A28A58F7264756E2164756E21

package/dist/index.js.map

@@ -0,0 +1,13 @@
+{
+  "version": 3,
+  "sources": ["../src/components/FormInstantProvider.tsx", "../src/utils/schemaParser.ts", "../src/components/FormInstantElement.tsx", "../src/utils/zodExtensions.ts"],
+  "sourcesContent": [
+    "import { createContext, useContext } from 'react';\nimport { zodResolverProps } from 'types';\nimport { parseSchema } from '../utils/schemaParser';\n\nexport const ZodResolverContext = createContext<zodResolverProps | null>(null);\n\nexport const FormInstantProvider: FCC<{\n    schema: zodResolverProps;\n}> = ({ children, schema }) => {\n    return <ZodResolverContext.Provider value={schema}>{children}</ZodResolverContext.Provider>;\n};\n\n/**\n * Hook to get a specific field by name from the schema\n */\nexport const useFields = <Sc extends Record<string, any>>(key: keyof Sc) => {\n    const schema = useContext(ZodResolverContext);\n    if (!schema) {\n        throw new Error('useFields must be used within FormInstantProvider');\n    }\n\n    const { fields } = parseSchema(schema);\n    return fields[key as string];\n};\n",
+    "import { z } from 'zod';\nimport { FieldConfig, FieldMetadata, SchemaPath } from '../types';\n\n// Schema type detection using the internal type property\nfunction getSchemaType(schema: z.ZodTypeAny): string {\n    return schema._zod?.def?.type || 'unknown';\n}\n\n/**\n * Extracts fieldConfig from a Zod schema\n */\nfunction extractFieldConfig(schema: z.ZodTypeAny) {\n    const fieldConfig = (schema as any)?._fieldConfig as FieldConfig<Record<string, object>>;\n    if (!fieldConfig) return undefined;\n\n    return fieldConfig;\n}\n\n/**\n * Parses a Zod schema and extracts metadata for mapping\n */\nexport function parseSchema(schema: z.ZodTypeAny): { fields: Record<string, any> } {\n    const fields: Record<string, FieldMetadata> = {};\n    const paths: SchemaPath[] = [];\n    const structure: Record<string, any> = {};\n\n    function extractShape(schema: z.ZodTypeAny): Record<string, any> {\n        // Handle ZodObject\n        if (schema instanceof z.ZodObject) {\n            return schema.shape;\n        }\n\n        // Handle ZodDiscriminatedUnion\n        if (schema instanceof z.ZodDiscriminatedUnion) {\n            // For discriminated unions, we'll use the first option as default\n            const options = schema.options;\n            if (options.length > 0) {\n                return extractShape(options[0] as z.ZodTypeAny);\n            }\n        }\n\n        return {};\n    }\n\n    function processField(\n        fieldName: string,\n        fieldSchema: z.ZodTypeAny,\n        parentPath: string = '',\n        parentStructure: Record<string, any> = structure,\n    ) {\n        // Extract fieldConfig from the schema\n        const fieldConfig = extractFieldConfig(fieldSchema);\n        const currentPath = parentPath ? `${parentPath}.${fieldName}` : fieldName;\n        const fieldType = fieldConfig?.fieldType || getSchemaType(fieldSchema);\n\n        // Check if field is required\n        const isOptional = fieldSchema instanceof z.ZodOptional;\n        const hasDefault = fieldSchema instanceof z.ZodDefault;\n        const isRequired = !isOptional && !hasDefault;\n\n        // Get default value\n        let defaultValue: any = undefined;\n        if (hasDefault) {\n            // For ZodDefault, try to get the default value\n            try {\n                const result = fieldSchema.safeParse(undefined);\n                if (result.success) {\n                    defaultValue = result.data;\n                }\n            } catch {\n                // Could not get default value\n            }\n        } else {\n            try {\n                const result = fieldSchema.safeParse(undefined);\n                if (result.success) {\n                    defaultValue = result.data;\n                }\n            } catch {\n                // Field is required, no default value\n            }\n        }\n\n        // Extract options for enums\n        const options: [string, string][] = (() => {\n            if (fieldSchema instanceof z.ZodEnum) {\n                return fieldSchema.options.map((value) => [String(value), String(value)]);\n            }\n\n            if (fieldSchema.constructor.name === 'ZodNativeEnum') {\n                const enumValues = (fieldSchema as z.ZodEnum).options;\n                return enumValues.map((value) => [String(value), String(value)]);\n            }\n            return [];\n        })();\n\n        // Create field metadata\n        const fieldMetadata: FieldMetadata = {\n            name: {\n                current: fieldName,\n                history: currentPath,\n            },\n            fieldType: fieldType,\n            required: isRequired,\n            default: defaultValue,\n            fieldConfig,\n            options,\n        };\n\n        // Store field metadata by path\n        fields[currentPath] = fieldMetadata;\n        paths.push(currentPath);\n        parentStructure[fieldName] = fieldMetadata;\n\n        // Handle nested objects\n        if (fieldSchema instanceof z.ZodObject) {\n            const nestedShape = fieldSchema.shape;\n            const nestedStructure: Record<string, any> = {};\n            parentStructure[fieldName] = nestedStructure;\n\n            Object.keys(nestedShape).forEach((nestedFieldName) => {\n                processField(\n                    nestedFieldName,\n                    nestedShape[nestedFieldName],\n                    currentPath,\n                    nestedStructure,\n                );\n            });\n        }\n\n        // Handle arrays\n        if (fieldSchema instanceof z.ZodArray) {\n            const elementSchema = fieldSchema.element;\n            if (elementSchema instanceof z.ZodObject) {\n                const arrayStructure: Record<string, any> = {};\n                parentStructure[fieldName] = arrayStructure;\n\n                const elementShape = elementSchema.shape;\n                Object.keys(elementShape).forEach((elementFieldName) => {\n                    processField(\n                        elementFieldName,\n                        elementShape[elementFieldName],\n                        `${currentPath}[0]`,\n                        arrayStructure,\n                    );\n                });\n            }\n        }\n    }\n\n    const shape = extractShape(schema);\n    Object.keys(shape).forEach((fieldName) => {\n        processField(fieldName, shape[fieldName]);\n    });\n\n    return {\n        fields,\n    };\n}\n\n/**\n * Gets the field type from a Zod schema\n */\nexport function getFieldType(schema: z.ZodTypeAny): string {\n    return getSchemaType(schema);\n}\n\n/**\n * Checks if a field is required\n */\nexport function isFieldRequired(schema: z.ZodTypeAny): boolean {\n    const isOptional = schema instanceof z.ZodOptional;\n    const hasDefault = schema instanceof z.ZodDefault;\n    return !isOptional && !hasDefault;\n}\n\n/**\n * Gets the default value for a field\n */\nexport function getDefaultValue(schema: z.ZodTypeAny): any {\n    try {\n        const result = schema.safeParse(undefined);\n        return result.success ? result.data : undefined;\n    } catch {\n        return undefined;\n    }\n}\n",
+    "'use client';\nimport { ElementMapping } from '@form-instant/react-input-mapping';\nimport { Fragment, useId } from 'react';\nimport { useFields } from './FormInstantProvider';\n\nexport interface ElementProps<Schema extends Record<string, any>> {\n    name: keyof Schema;\n}\n\nexport const FormInstantElement = <S extends Record<string, any>>({ name }: ElementProps<S>) => {\n    const field = useFields(name);\n\n    const id = useId();\n\n    if (!['object'].includes(field.fieldType)) return <ElementMapping formProps={field} />;\n\n    return (\n        <>\n            {Object.values(field.schema || {}).map((props: any) => {\n                return (\n                    <Fragment key={`${id}-${props.name?.history || ''}`}>\n                        <ElementMapping formProps={props} />\n                    </Fragment>\n                );\n            })}\n        </>\n    );\n};\n",
+    "import { z } from 'zod';\n\n// Base field configuration options interface\nexport interface BaseFieldConfigOptions {\n    [key: string]: any; // Allow additional custom properties\n}\n\n// Generic field configuration options that extends the base\nexport type FieldConfigOptions<T = BaseFieldConfigOptions> = T & BaseFieldConfigOptions;\n\n// Function to extend Zod globally with fieldConfig method\nexport function extendZodWithFieldConfig() {\n    // Extend the base ZodType prototype to add fieldConfig method\n    const zodTypePrototype = Object.getPrototypeOf(z.string());\n\n    // Add fieldConfig method to all Zod schemas\n    Object.defineProperty(zodTypePrototype, 'fieldConfig', {\n        value: function <TConfig = BaseFieldConfigOptions>(config: FieldConfigOptions<TConfig>) {\n            (this as any)._fieldConfig = config;\n            return this;\n        },\n        writable: true,\n        configurable: true,\n    });\n\n    // Create extended constructors that automatically add fieldConfig\n    const extendedConstructors = {\n        object: <T extends z.ZodRawShape>(shape: T) => {\n            const schema = z.object(shape);\n            return Object.assign(schema, {\n                fieldConfig: <TConfig = BaseFieldConfigOptions>(\n                    config: FieldConfigOptions<TConfig>,\n                ) => {\n                    (schema as any)._fieldConfig = config;\n                    return schema;\n                },\n            });\n        },\n        array: <T extends z.ZodTypeAny>(element: T) => {\n            const schema = z.array(element);\n            return Object.assign(schema, {\n                fieldConfig: <TConfig = BaseFieldConfigOptions>(\n                    config: FieldConfigOptions<TConfig>,\n                ) => {\n                    (schema as any)._fieldConfig = config;\n                    return schema;\n                },\n            });\n        },\n        string: () => {\n            const schema = z.string();\n            return Object.assign(schema, {\n                fieldConfig: <TConfig = BaseFieldConfigOptions>(\n                    config: FieldConfigOptions<TConfig>,\n                ) => {\n                    (schema as any)._fieldConfig = config;\n                    return schema;\n                },\n            });\n        },\n        email: () => {\n            const schema = z.string();\n            return Object.assign(schema, {\n                fieldConfig: <TConfig = BaseFieldConfigOptions>(\n                    config: FieldConfigOptions<TConfig>,\n                ) => {\n                    (schema as any)._fieldConfig = config;\n                    return schema;\n                },\n            });\n        },\n        number: () => {\n            const schema = z.number();\n            return Object.assign(schema, {\n                fieldConfig: <TConfig = BaseFieldConfigOptions>(\n                    config: FieldConfigOptions<TConfig>,\n                ) => {\n                    (schema as any)._fieldConfig = config;\n                    return schema;\n                },\n            });\n        },\n        boolean: () => {\n            const schema = z.boolean();\n            return Object.assign(schema, {\n                fieldConfig: <TConfig = BaseFieldConfigOptions>(\n                    config: FieldConfigOptions<TConfig>,\n                ) => {\n                    (schema as any)._fieldConfig = config;\n                    return schema;\n                },\n            });\n        },\n        date: () => {\n            const schema = z.date();\n            return Object.assign(schema, {\n                fieldConfig: <TConfig = BaseFieldConfigOptions>(\n                    config: FieldConfigOptions<TConfig>,\n                ) => {\n                    (schema as any)._fieldConfig = config;\n                    return schema;\n                },\n            });\n        },\n        enum: <T extends [string, ...string[]]>(values: T) => {\n            const schema = z.enum(values);\n            return Object.assign(schema, {\n                fieldConfig: <TConfig = BaseFieldConfigOptions>(\n                    config: FieldConfigOptions<TConfig>,\n                ) => {\n                    (schema as any)._fieldConfig = config;\n                    return schema;\n                },\n            });\n        },\n        union: <T extends [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]>(types: T) => {\n            const schema = z.union(types);\n            return Object.assign(schema, {\n                fieldConfig: <TConfig = BaseFieldConfigOptions>(\n                    config: FieldConfigOptions<TConfig>,\n                ) => {\n                    (schema as any)._fieldConfig = config;\n                    return schema;\n                },\n            });\n        },\n        optional: <T extends z.ZodTypeAny>(schema: T) => {\n            const optionalSchema = z.optional(schema);\n            // Preserve fieldConfig from the original schema\n            if ((schema as any).fieldConfig) {\n                Object.assign(optionalSchema, {\n                    fieldConfig: (schema as any).fieldConfig,\n                    _fieldConfig: (schema as any)._fieldConfig,\n                });\n            } else {\n                Object.assign(optionalSchema, {\n                    fieldConfig: <TConfig = BaseFieldConfigOptions>(\n                        config: FieldConfigOptions<TConfig>,\n                    ) => {\n                        (optionalSchema as any)._fieldConfig = config;\n                        return optionalSchema;\n                    },\n                });\n            }\n            return optionalSchema;\n        },\n        nullable: <T extends z.ZodTypeAny>(schema: T) => {\n            const nullableSchema = z.nullable(schema);\n            // Preserve fieldConfig from the original schema\n            if ((schema as any).fieldConfig) {\n                Object.assign(nullableSchema, {\n                    fieldConfig: (schema as any).fieldConfig,\n                    _fieldConfig: (schema as any)._fieldConfig,\n                });\n            } else {\n                Object.assign(nullableSchema, {\n                    fieldConfig: <TConfig = BaseFieldConfigOptions>(\n                        config: FieldConfigOptions<TConfig>,\n                    ) => {\n                        (nullableSchema as any)._fieldConfig = config;\n                        return nullableSchema;\n                    },\n                });\n            }\n            return nullableSchema;\n        },\n    };\n\n    // Create extended Zod instance\n    const zExtended = {\n        ...z,\n        ...extendedConstructors,\n    };\n\n    return zExtended;\n}\n\n// Initialize the extended Zod instance\nexport const zExtended = extendZodWithFieldConfig();\n\n// Export the extended Zod instance as the default\nexport { zExtended as z };\n\n// Helper function to get field configuration from a schema\nexport function getFieldConfig<T = BaseFieldConfigOptions>(\n    schema: z.ZodTypeAny,\n): FieldConfigOptions<T> | undefined {\n    return (schema as any)._fieldConfig;\n}\n\n// Helper function to set field configuration on an existing schema\nexport function setFieldConfig<T = BaseFieldConfigOptions>(\n    schema: z.ZodTypeAny,\n    config: FieldConfigOptions<T>,\n): z.ZodTypeAny {\n    (schema as any)._fieldConfig = config;\n    return schema;\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "14376D9A28A58F7264756E2164756E21",
+  "names": []
+}

package/dist/types.d.ts

@@ -0,0 +1,48 @@
+import { ParsedField } from '@form-instant/react-input-mapping';
+import { ReactNode } from 'react';
+export type ZodSchema = any;
+export type ComponentMapping = Record<string, React.ComponentType<any>>;
+export type SchemaPath = string;
+export type PathSegment = string;
+export type FieldConfig<Ob, K extends keyof Ob = keyof Ob> = {
+    fieldType: K;
+} & Ob[K];
+export type FieldMetadata = ParsedField<any, string>;
+export interface SchemaMetadata {
+    fields: Record<string, FieldMetadata>;
+    paths: SchemaPath[];
+    structure: Record<string, any>;
+}
+export interface MappingConfig {
+    componentMapping: ComponentMapping;
+    defaultComponent?: React.ComponentType<any>;
+    transformProps?: (props: any) => any;
+}
+export interface SchemaMappingResult {
+    schema: ZodSchema;
+    metadata: SchemaMetadata;
+    mappingConfig: MappingConfig;
+}
+export interface SchemaNavigationResult {
+    navigate: (path: SchemaPath) => FieldMetadata | null;
+    getField: (path: SchemaPath) => FieldMetadata | null;
+    getPaths: () => SchemaPath[];
+    hasPath: (path: SchemaPath) => boolean;
+}
+export interface SchemaMetadataResult {
+    metadata: SchemaMetadata;
+    getField: (path: SchemaPath) => FieldMetadata | null;
+    getPaths: () => SchemaPath[];
+    getStructure: () => Record<string, any>;
+}
+export type zodResolverProps = ZodSchema;
+export interface SchemaMapperProps {
+    schema: ZodSchema;
+    componentMapping: ComponentMapping;
+    defaultComponent?: React.ComponentType<any>;
+    transformProps?: (props: any) => any;
+    children?: ReactNode;
+}
+export interface ElementProps<Schema extends Record<string, any>> {
+    name: keyof Schema;
+}

package/dist/utils/pathResolver.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { SchemaPath, PathSegment, FieldMetadata } from '../types';
+/**
+ * Resolves a path in a Zod schema and returns the field metadata
+ */
+export declare function resolvePath(schema: z.ZodTypeAny, path: SchemaPath): FieldMetadata | null;
+/**
+ * Gets all possible paths in a schema
+ */
+export declare function getAllPaths(schema: z.ZodTypeAny): SchemaPath[];
+/**
+ * Validates if a path exists in the schema
+ */
+export declare function hasPath(schema: z.ZodTypeAny, path: SchemaPath): boolean;
+/**
+ * Gets the schema at a specific path
+ */
+export declare function getSchemaAtPath(schema: z.ZodTypeAny, path: SchemaPath): z.ZodTypeAny | null;
+/**
+ * Splits a path into segments
+ */
+export declare function splitPath(path: SchemaPath): PathSegment[];
+/**
+ * Joins path segments into a path
+ */
+export declare function joinPath(segments: PathSegment[]): SchemaPath;

package/dist/utils/schemaParser.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+/**
+ * Parses a Zod schema and extracts metadata for mapping
+ */
+export declare function parseSchema(schema: z.ZodTypeAny): {
+    fields: Record<string, any>;
+};
+/**
+ * Gets the field type from a Zod schema
+ */
+export declare function getFieldType(schema: z.ZodTypeAny): string;
+/**
+ * Checks if a field is required
+ */
+export declare function isFieldRequired(schema: z.ZodTypeAny): boolean;
+/**
+ * Gets the default value for a field
+ */
+export declare function getDefaultValue(schema: z.ZodTypeAny): any;