@buildnbuzz/buzzform 0.1.0 → 0.1.2

package/dist/index.js

@@ -22,7 +22,6 @@ var src_exports = {};
 __export(src_exports, {
   FormConfigContext: () => FormConfigContext,
   FormProvider: () => FormProvider,
-  applyCustomValidation: () => applyCustomValidation,
   applyNumericPrecision: () => applyNumericPrecision,
   clampNumber: () => clampNumber,
   coerceToDate: () => coerceToDate,
@@ -125,59 +124,26 @@ function extractValidationConfig(validate) {
   }
   return { fn: void 0, isLive: false };
 }
-function applyCustomValidation(schema, field, fieldPath = "") {
-  if (!("validate" in field)) {
-    return schema;
-  }
-  const fieldWithValidate = field;
-  if (!fieldWithValidate.validate) {
-    return schema;
-  }
-  const config = extractValidationConfig(fieldWithValidate.validate);
-  if (!config.fn) {
-    return schema;
-  }
-  return schema.superRefine(async (val, ctx) => {
-    const result = await config.fn(val, {
-      data: {},
-      siblingData: {},
-      path: fieldPath.split(".")
-    });
-    if (result !== true) {
-      ctx.addIssue({
-        code: import_zod.z.ZodIssueCode.custom,
-        message: typeof result === "string" ? result : "Validation failed"
-      });
-    }
-  });
-}
 function makeOptional(schema, fieldType) {
   switch (fieldType) {
-    // String types: allow empty string
     case "text":
     case "textarea":
     case "email":
     case "password":
       return schema.optional().or(import_zod.z.literal(""));
-    // Nullable types
     case "number":
     case "date":
     case "select":
     case "radio":
       return schema.optional().nullable();
-    // Boolean types: always have a value
     case "checkbox":
     case "switch":
       return schema;
-    // Booleans are never "optional" in the traditional sense
-    // Array types
     case "tags":
     case "array":
       return schema.optional().default([]);
-    // Upload
     case "upload":
       return schema.optional().nullable();
-    // Default
     default:
       return schema.optional();
   }
@@ -234,25 +200,25 @@ function isFileTypeAccepted(file, accept) {
 
 // src/schema/builders/text.ts
 function createTextFieldSchema(field) {
-  let schema = import_zod2.z.string();
+  let schema = import_zod2.z.string({ error: "This field is required" });
   if ("pattern" in field && field.pattern) {
     const pattern = typeof field.pattern === "string" ? new RegExp(field.pattern) : field.pattern;
     schema = schema.regex(pattern, {
-      message: getPatternErrorMessage(field.pattern)
+      error: getPatternErrorMessage(field.pattern)
     });
   }
   if (field.minLength) {
     schema = schema.min(field.minLength, {
-      message: `Must be at least ${field.minLength} characters`
+      error: `Must be at least ${field.minLength} characters`
     });
   }
   if (field.maxLength) {
     schema = schema.max(field.maxLength, {
-      message: `Must be no more than ${field.maxLength} characters`
+      error: `Must be no more than ${field.maxLength} characters`
     });
   }
   if (field.required) {
-    schema = schema.min(1, { message: "This field is required" });
+    schema = schema.min(1, { error: "This field is required" });
   }
   let finalSchema = schema;
   if ("trim" in field && field.trim) {
@@ -260,67 +226,63 @@ function createTextFieldSchema(field) {
       return typeof val === "string" ? val.trim() : val;
     }, schema);
   }
-  finalSchema = applyCustomValidation(finalSchema, field, field.name);
   if (!field.required) {
     return makeOptional(finalSchema, field.type);
   }
   return finalSchema;
 }
 function createEmailFieldSchema(field) {
-  let schema = import_zod2.z.string().email({ message: "Invalid email address" });
+  let schema = import_zod2.z.email({ error: "Invalid email address" });
   if (field.minLength) {
     schema = schema.min(field.minLength, {
-      message: `Must be at least ${field.minLength} characters`
+      error: `Must be at least ${field.minLength} characters`
     });
   }
   if (field.maxLength) {
     schema = schema.max(field.maxLength, {
-      message: `Must be no more than ${field.maxLength} characters`
+      error: `Must be no more than ${field.maxLength} characters`
     });
   }
   if (field.required) {
-    schema = schema.min(1, { message: "Email is required" });
+    schema = schema.min(1, { error: "Email is required" });
   }
-  const finalSchema = applyCustomValidation(schema, field, field.name);
   if (!field.required) {
-    return makeOptional(finalSchema, "email");
+    return makeOptional(schema, "email");
   }
-  return finalSchema;
+  return schema;
 }
 function createPasswordFieldSchema(field) {
-  let schema = import_zod2.z.string();
+  let schema = import_zod2.z.string({ error: "Password is required" });
   if (field.minLength) {
     schema = schema.min(field.minLength, {
-      message: `Password must be at least ${field.minLength} characters`
+      error: `Password must be at least ${field.minLength} characters`
     });
   }
   if (field.maxLength) {
     schema = schema.max(field.maxLength, {
-      message: `Password must be no more than ${field.maxLength} characters`
+      error: `Password must be no more than ${field.maxLength} characters`
     });
   }
   if (field.required) {
-    schema = schema.min(1, { message: "Password is required" });
+    schema = schema.min(1, { error: "Password is required" });
   }
-  const finalSchema = applyCustomValidation(schema, field, field.name);
   if (!field.required) {
-    return makeOptional(finalSchema, "password");
+    return makeOptional(schema, "password");
   }
-  return finalSchema;
+  return schema;
 }
 
 // src/schema/builders/number.ts
 var import_zod3 = require("zod");
 function createNumberFieldSchema(field) {
-  let numSchema = import_zod3.z.number({ invalid_type_error: "Must be a number" });
+  let numSchema = import_zod3.z.number({ error: "Must be a number" });
   if (field.min !== void 0) {
     numSchema = numSchema.min(field.min, `Must be at least ${field.min}`);
   }
   if (field.max !== void 0) {
     numSchema = numSchema.max(field.max, `Must be at most ${field.max}`);
   }
-  let schema = import_zod3.z.preprocess(coerceToNumber, numSchema);
-  schema = applyCustomValidation(schema, field, field.name);
+  const schema = import_zod3.z.preprocess(coerceToNumber, numSchema);
   if (field.required) {
     return schema;
   }
@@ -339,21 +301,20 @@ function createDateFieldSchema(field) {
   const isDatetime = field.type === "datetime";
   const minDate = toDate(field.minDate);
   const maxDate = toDate(field.maxDate);
-  let dateSchema = import_zod4.z.date({ invalid_type_error: "Please enter a valid date" });
+  let dateSchema = import_zod4.z.date({ error: "Please enter a valid date" });
   if (minDate) {
     const formattedDate = isDatetime ? minDate.toLocaleString() : minDate.toDateString();
     dateSchema = dateSchema.min(minDate, {
-      message: `Date must be on or after ${formattedDate}`
+      error: `Date must be on or after ${formattedDate}`
     });
   }
   if (maxDate) {
     const formattedDate = isDatetime ? maxDate.toLocaleString() : maxDate.toDateString();
     dateSchema = dateSchema.max(maxDate, {
-      message: `Date must be on or before ${formattedDate}`
+      error: `Date must be on or before ${formattedDate}`
     });
   }
-  let schema = import_zod4.z.preprocess(coerceToDate, dateSchema);
-  schema = applyCustomValidation(schema, field, field.name);
+  const schema = import_zod4.z.preprocess(coerceToDate, dateSchema);
   if (field.required) {
     return schema.refine(
       (val) => val instanceof Date && !isNaN(val.getTime()),
@@ -365,18 +326,21 @@ function createDateFieldSchema(field) {
 
 // src/schema/builders/select.ts
 var import_zod5 = require("zod");
-var selectValueSchema = import_zod5.z.union([import_zod5.z.string(), import_zod5.z.number(), import_zod5.z.boolean()]);
+var selectValueSchema = import_zod5.z.union([
+  import_zod5.z.string({ error: "Please select an option" }),
+  import_zod5.z.number({ error: "Please select an option" }),
+  import_zod5.z.boolean({ error: "Please select an option" })
+], { error: "Please select an option" });
 function createSelectFieldSchema(field) {
   if (field.hasMany) {
-    let arraySchema = import_zod5.z.array(selectValueSchema);
+    let arraySchema = import_zod5.z.array(selectValueSchema, { error: "Invalid selection" });
     if (field.required) {
       arraySchema = arraySchema.min(1, "Select at least one option");
     }
-    const schema2 = applyCustomValidation(arraySchema, field, field.name);
     if (!field.required) {
-      return schema2.optional().default([]);
+      return arraySchema.optional().default([]);
     }
-    return schema2;
+    return arraySchema;
   }
   let schema = selectValueSchema;
   if (field.required) {
@@ -385,7 +349,6 @@ function createSelectFieldSchema(field) {
       "Please select an option"
     );
   }
-  schema = applyCustomValidation(schema, field, field.name);
   if (!field.required) {
     return makeOptional(schema, "select");
   }
@@ -399,7 +362,6 @@ function createRadioFieldSchema(field) {
       "Please select an option"
     );
   }
-  schema = applyCustomValidation(schema, field, field.name);
   if (!field.required) {
     return makeOptional(schema, "radio");
   }
@@ -409,146 +371,113 @@ function createRadioFieldSchema(field) {
 // src/schema/builders/boolean.ts
 var import_zod6 = require("zod");
 function createCheckboxFieldSchema(field) {
-  let schema = import_zod6.z.boolean();
+  let schema = import_zod6.z.boolean({ error: "Invalid value" });
   if (field.required) {
-    schema = import_zod6.z.boolean().refine((val) => val === true, {
-      message: "This field is required"
+    schema = import_zod6.z.boolean({ error: "This field is required" }).refine((val) => val === true, {
+      error: "This field is required"
     });
   }
-  return applyCustomValidation(schema, field, field.name);
+  return schema;
 }
 function createSwitchFieldSchema(field) {
-  let schema = import_zod6.z.boolean();
+  let schema = import_zod6.z.boolean({ error: "Invalid value" });
   if (field.required) {
-    schema = import_zod6.z.boolean().refine((val) => val === true, {
-      message: "This field is required"
+    schema = import_zod6.z.boolean({ error: "This field is required" }).refine((val) => val === true, {
+      error: "This field is required"
     });
   }
-  return applyCustomValidation(schema, field, field.name);
+  return schema;
 }
 
 // src/schema/builders/upload.ts
 var import_zod7 = require("zod");
-function validateSingleFile(value, field) {
-  if (value === null || value === void 0 || value === "") {
-    return { valid: true };
-  }
-  if (typeof value === "string") {
-    return { valid: true };
+function matchesMimePattern(fileType, pattern) {
+  const normalizedPattern = pattern.toLowerCase().trim();
+  const normalizedType = fileType.toLowerCase();
+  if (normalizedPattern.endsWith("/*")) {
+    const category = normalizedPattern.replace("/*", "");
+    return normalizedType.startsWith(category + "/");
   }
-  if (!isFileLike(value)) {
-    return { valid: false, message: "Invalid file" };
+  if (normalizedPattern.startsWith(".")) {
+    return true;
   }
-  if (field.maxSize && value.size > field.maxSize) {
+  return normalizedType === normalizedPattern;
+}
+function isFileTypeAccepted2(file, acceptPatterns) {
+  if (!file.type) return true;
+  return acceptPatterns.some((pattern) => matchesMimePattern(file.type, pattern));
+}
+function createUploadFieldSchema(field) {
+  let fileSchema = import_zod7.z.file({ error: "Please select a file" });
+  if (field.maxSize) {
     const sizeMB = (field.maxSize / 1024 / 1024).toFixed(1);
-    return {
-      valid: false,
-      message: `File must be smaller than ${sizeMB}MB`
-    };
+    fileSchema = fileSchema.max(field.maxSize, {
+      error: `File must be smaller than ${sizeMB}MB`
+    });
   }
   const accept = field.ui?.accept;
   if (accept && accept !== "*") {
-    if (!isFileTypeAccepted(value, accept)) {
-      return {
-        valid: false,
-        message: `File type not allowed. Accepted: ${accept}`
-      };
+    const acceptPatterns = accept.split(",").map((t) => t.trim());
+    const hasWildcard = acceptPatterns.some((p) => p.includes("*") || p.startsWith("."));
+    if (hasWildcard) {
+      fileSchema = fileSchema.refine(
+        (file) => isFileTypeAccepted2(file, acceptPatterns),
+        `File type not allowed. Accepted: ${accept}`
+      );
+    } else {
+      fileSchema = fileSchema.mime(acceptPatterns, {
+        error: `File type not allowed. Accepted: ${accept}`
+      });
     }
   }
-  return { valid: true };
-}
-function createUploadFieldSchema(field) {
+  const fileOrUrl = import_zod7.z.union([
+    fileSchema,
+    import_zod7.z.string({ error: "Invalid file" })
+  ], { error: "Please select a file" });
   if (field.hasMany) {
-    const schema2 = import_zod7.z.array(import_zod7.z.any()).superRefine((files, ctx) => {
-      for (let i = 0; i < files.length; i++) {
-        const file = files[i];
-        const result = validateSingleFile(file, field);
-        if (!result.valid) {
-          ctx.addIssue({
-            code: import_zod7.z.ZodIssueCode.custom,
-            message: result.message || "Invalid file",
-            path: [i]
-          });
-        }
-      }
-      if (field.required) {
-        const validFiles = files.filter((f) => f !== null && f !== void 0);
-        if (validFiles.length === 0) {
-          ctx.addIssue({
-            code: import_zod7.z.ZodIssueCode.custom,
-            message: "At least one file is required"
-          });
-        }
-      }
-      if (field.minFiles !== void 0 && field.minFiles > 0) {
-        const validFiles = files.filter((f) => f !== null && f !== void 0);
-        if (validFiles.length < field.minFiles) {
-          ctx.addIssue({
-            code: import_zod7.z.ZodIssueCode.custom,
-            message: `At least ${field.minFiles} file(s) required`
-          });
-        }
-      }
-      if (field.maxFiles !== void 0) {
-        const validFiles = files.filter((f) => f !== null && f !== void 0);
-        if (validFiles.length > field.maxFiles) {
-          ctx.addIssue({
-            code: import_zod7.z.ZodIssueCode.custom,
-            message: `Maximum ${field.maxFiles} file(s) allowed`
-          });
-        }
-      }
-    });
-    if (!field.required) {
-      return schema2.optional().default([]);
-    }
-    return schema2;
-  }
-  const schema = import_zod7.z.any().superRefine((value, ctx) => {
-    if (field.required && (value === null || value === void 0 || value === "")) {
-      ctx.addIssue({
-        code: import_zod7.z.ZodIssueCode.custom,
-        message: "File is required"
+    let arraySchema = import_zod7.z.array(fileOrUrl, { error: "Invalid files" });
+    if (field.minFiles !== void 0 && field.minFiles > 0) {
+      arraySchema = arraySchema.min(field.minFiles, {
+        error: `At least ${field.minFiles} file(s) required`
       });
-      return;
     }
-    if (value === null || value === void 0 || value === "") {
-      return;
+    if (field.maxFiles !== void 0) {
+      arraySchema = arraySchema.max(field.maxFiles, {
+        error: `Maximum ${field.maxFiles} file(s) allowed`
+      });
     }
-    const result = validateSingleFile(value, field);
-    if (!result.valid) {
-      ctx.addIssue({
-        code: import_zod7.z.ZodIssueCode.custom,
-        message: result.message || "Invalid file"
+    if (field.required) {
+      arraySchema = arraySchema.min(1, {
+        error: "At least one file is required"
       });
+      return arraySchema;
     }
-  });
-  if (!field.required) {
-    return schema.optional().nullable();
+    return arraySchema.optional().default([]);
   }
-  return schema;
+  if (field.required) {
+    return fileOrUrl;
+  }
+  return fileOrUrl.optional().nullable();
 }
 
 // src/schema/builders/tags.ts
 var import_zod8 = require("zod");
 function createTagsFieldSchema(field) {
-  const tagSchema = import_zod8.z.string();
-  let schema = import_zod8.z.array(tagSchema);
+  const tagSchema = import_zod8.z.string({ error: "Invalid tag" });
+  let schema = import_zod8.z.array(tagSchema, { error: "Invalid tags" });
   if (field.minTags !== void 0) {
     schema = schema.min(field.minTags, `At least ${field.minTags} tag(s) required`);
   }
   if (field.maxTags !== void 0) {
     schema = schema.max(field.maxTags, `Maximum ${field.maxTags} tag(s) allowed`);
   }
-  let finalSchema = applyCustomValidation(schema, field, field.name);
   if (field.required) {
-    finalSchema = finalSchema.refine(
+    return schema.refine(
       (arr) => Array.isArray(arr) && arr.length > 0,
       "At least one tag is required"
     );
-    return finalSchema;
   }
-  return finalSchema.optional().default([]);
+  return schema.optional().default([]);
 }
 
 // src/schema/builders/composite.ts
@@ -587,7 +516,6 @@ function fieldToZod(field) {
     return field.schema;
   }
   switch (field.type) {
-    // Text-based fields
     case "text":
       return createTextFieldSchema(field);
     case "email":
@@ -596,35 +524,27 @@ function fieldToZod(field) {
       return createPasswordFieldSchema(field);
     case "textarea":
       return createTextFieldSchema(field);
-    // Number
     case "number":
       return createNumberFieldSchema(field);
-    // Date
     case "date":
     case "datetime":
       return createDateFieldSchema(field);
-    // Selection
     case "select":
       return createSelectFieldSchema(field);
     case "radio":
       return createRadioFieldSchema(field);
-    // Boolean
     case "checkbox":
       return createCheckboxFieldSchema(field);
     case "switch":
       return createSwitchFieldSchema(field);
-    // Upload
     case "upload":
       return createUploadFieldSchema(field);
-    // Tags
     case "tags":
       return createTagsFieldSchema(field);
-    // Composite (recursive)
     case "array":
       return createArrayFieldSchema(field, fieldsToZodSchema);
     case "group":
       return createGroupFieldSchema(field, fieldsToZodSchema);
-    // Layout fields don't produce schemas directly
     case "row":
     case "collapsible":
     case "tabs":
@@ -992,7 +912,6 @@ function useForm(options) {
 0 && (module.exports = {
   FormConfigContext,
   FormProvider,
-  applyCustomValidation,
   applyNumericPrecision,
   clampNumber,
   coerceToDate,