@dragonmastery/zinia-forms-core 0.3.16 → 0.3.17

package/dist/index.d.ts

@@ -1516,7 +1516,7 @@ declare function useForm<T extends z.ZodObject<any>, CalcType = (values: z.infer
             timestamp: number;
             timeoutId?: number;
         }[]>;
-        fieldsMetadata: Record<string, FieldMetadata>;
+        readonly fieldsMetadata: Record<string, FieldMetadata>;
         validate: (options?: {
             markErrorsAsTouched: boolean;
         }) => boolean;

package/dist/index.js

@@ -651,6 +651,12 @@ var SchemaCache = class {
             if (debug) {
               console.log(`[SchemaCache] More segments remaining, continuing to next segment`);
             }
+            if (!(currentSchema instanceof z.ZodObject)) {
+              if (debug) {
+                console.log(`[SchemaCache] ERROR: Element schema is not a ZodObject after unwrap, cannot access nested fields`);
+              }
+              return null;
+            }
             continue;
           }
           if (debug) {
@@ -1058,6 +1064,11 @@ function extractFieldMetadata(schema, path = "", parentSchema, schemaId) {
     metadata.isArray = true;
     if (schema._def.minLength) {
       metadata.min = schema._def.minLength.value;
+      if (schema._def.minLength.value > 0) ; else {
+        metadata.isRequired = false;
+      }
+    } else {
+      metadata.isRequired = false;
     }
     if (schema._def.maxLength) {
       metadata.max = schema._def.maxLength.value;
@@ -1174,9 +1185,7 @@ function extractFieldMetadata(schema, path = "", parentSchema, schemaId) {
           } else if (customMetadata.options) {
             metadata.options = customMetadata.options;
           } else {
-            metadata.options = [
-              { value: "", label: "Select an option" }
-            ];
+            metadata.options = [{ value: "", label: "Select an option" }];
           }
         }
       }
@@ -1815,6 +1824,83 @@ function useFormValidation(schema, formState, options) {
     validateField: validateField2
   };
 }
+
+// src/metadata/resolveMetadataPath.ts
+function resolveMetadataPath(fieldsMetadata, path) {
+  if (path in fieldsMetadata) {
+    return fieldsMetadata[path];
+  }
+  return resolveMetadataPathRecursive(fieldsMetadata, path.split("."), 0);
+}
+function resolveMetadataPathRecursive(fieldsMetadata, segments, startIndex, currentMetadata) {
+  if (startIndex >= segments.length) {
+    return void 0;
+  }
+  if (currentMetadata) {
+    const segment = segments[startIndex];
+    if (!isNaN(Number(segment))) {
+      if (currentMetadata.arrayOf) {
+        return resolveMetadataPathRecursive(fieldsMetadata, segments, startIndex + 1, currentMetadata.arrayOf);
+      }
+      return void 0;
+    } else {
+      if (currentMetadata.children) {
+        const childMetadata = currentMetadata.children[segment];
+        if (childMetadata) {
+          if (startIndex + 1 < segments.length) {
+            return resolveMetadataPathRecursive(fieldsMetadata, segments, startIndex + 1, childMetadata);
+          }
+          return {
+            ...childMetadata,
+            path: segments.join(".")
+          };
+        }
+      }
+      return void 0;
+    }
+  } else {
+    const segment = segments[startIndex];
+    const rootMetadata = fieldsMetadata[segment];
+    if (!rootMetadata) {
+      return void 0;
+    }
+    if (startIndex + 1 < segments.length) {
+      return resolveMetadataPathRecursive(fieldsMetadata, segments, startIndex + 1, rootMetadata);
+    }
+    return {
+      ...rootMetadata,
+      path: segments.join(".")
+    };
+  }
+}
+function createMetadataProxy(fieldsMetadata) {
+  return new Proxy(fieldsMetadata, {
+    get(target, prop) {
+      if (typeof prop !== "string") {
+        return Reflect.get(target, prop);
+      }
+      return resolveMetadataPath(fieldsMetadata, prop);
+    },
+    has(target, prop) {
+      if (typeof prop !== "string") {
+        return prop in target;
+      }
+      if (prop in target) {
+        return true;
+      }
+      return resolveMetadataPath(fieldsMetadata, prop) !== void 0;
+    },
+    ownKeys(target) {
+      return Reflect.ownKeys(target);
+    },
+    getOwnPropertyDescriptor(target, prop) {
+      if (prop in target) {
+        return Reflect.getOwnPropertyDescriptor(target, prop);
+      }
+      return void 0;
+    }
+  });
+}
 function setupLocalStoragePersistence(formData, options) {
   const { storeName, enabled = true, initialValues = {}, debug = false } = options;
   const logger = Logger.getLogger("LocalStoragePersistence");
@@ -2059,7 +2145,11 @@ function useForm(schema, options) {
     get pendingOperations() {
       return formState.state.pendingOperations;
     },
-    fieldsMetadata,
+    // Create a Proxy for fieldsMetadata that automatically resolves nested array paths
+    // This allows fieldsMetadata[path] to work for nested array paths like "items.0.fieldName"
+    get fieldsMetadata() {
+      return createMetadataProxy(fieldsMetadata);
+    },
     // Form methods
     validate: validation.validate,
     validateField: validation.validateField,