@buildnbuzz/buzzform 0.1.0

package/dist/chunk-K42S5YX3.mjs

@@ -0,0 +1,599 @@
+// src/schema/fields-to-schema.ts
+import { z as z10 } from "zod";
+
+// src/schema/builders/text.ts
+import { z as z2 } from "zod";
+
+// src/schema/helpers.ts
+import { z } from "zod";
+function extractValidationConfig(validate) {
+  if (!validate) {
+    return { fn: void 0, isLive: false };
+  }
+  if (typeof validate === "function") {
+    return { fn: validate, isLive: false };
+  }
+  if (typeof validate === "object" && "fn" in validate) {
+    const obj = validate;
+    const fn = typeof obj.fn === "function" ? obj.fn : void 0;
+    if (!obj.live) {
+      return { fn, isLive: false };
+    }
+    const debounceMs = typeof obj.live === "object" ? obj.live.debounceMs : void 0;
+    return { fn, isLive: true, debounceMs };
+  }
+  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: 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(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();
+  }
+}
+function coerceToNumber(val) {
+  if (val === "" || val === null || val === void 0) {
+    return void 0;
+  }
+  const num = Number(val);
+  return isNaN(num) ? void 0 : num;
+}
+function coerceToDate(val) {
+  if (val === "" || val === null || val === void 0) {
+    return void 0;
+  }
+  if (val instanceof Date) {
+    return isNaN(val.getTime()) ? void 0 : val;
+  }
+  if (typeof val === "string" || typeof val === "number") {
+    const d = new Date(val);
+    return isNaN(d.getTime()) ? void 0 : d;
+  }
+  return void 0;
+}
+var PATTERN_MESSAGES = {
+  "^[a-zA-Z0-9_]+$": "Only letters, numbers, and underscores allowed",
+  "^[a-z0-9-]+$": "Only lowercase letters, numbers, and hyphens allowed",
+  "^\\S+@\\S+\\.\\S+$": "Invalid email format",
+  "^https?://": "Must start with http:// or https://"
+};
+function getPatternErrorMessage(pattern) {
+  const patternStr = typeof pattern === "string" ? pattern : pattern.source;
+  return PATTERN_MESSAGES[patternStr] || `Must match pattern: ${patternStr}`;
+}
+function isFileLike(value) {
+  return typeof value === "object" && value !== null && "name" in value && "size" in value && "type" in value;
+}
+function isFileTypeAccepted(file, accept) {
+  if (accept === "*" || !accept) return true;
+  const acceptTypes = accept.split(",").map((t) => t.trim().toLowerCase());
+  const fileType = file.type.toLowerCase();
+  const fileName = file.name.toLowerCase();
+  return acceptTypes.some((acceptType) => {
+    if (acceptType.endsWith("/*")) {
+      const category = acceptType.replace("/*", "");
+      return fileType.startsWith(category + "/");
+    }
+    if (acceptType.startsWith(".")) {
+      return fileName.endsWith(acceptType);
+    }
+    return fileType === acceptType;
+  });
+}
+
+// src/schema/builders/text.ts
+function createTextFieldSchema(field) {
+  let schema = z2.string();
+  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)
+    });
+  }
+  if (field.minLength) {
+    schema = schema.min(field.minLength, {
+      message: `Must be at least ${field.minLength} characters`
+    });
+  }
+  if (field.maxLength) {
+    schema = schema.max(field.maxLength, {
+      message: `Must be no more than ${field.maxLength} characters`
+    });
+  }
+  if (field.required) {
+    schema = schema.min(1, { message: "This field is required" });
+  }
+  let finalSchema = schema;
+  if ("trim" in field && field.trim) {
+    finalSchema = z2.preprocess((val) => {
+      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 = z2.string().email({ message: "Invalid email address" });
+  if (field.minLength) {
+    schema = schema.min(field.minLength, {
+      message: `Must be at least ${field.minLength} characters`
+    });
+  }
+  if (field.maxLength) {
+    schema = schema.max(field.maxLength, {
+      message: `Must be no more than ${field.maxLength} characters`
+    });
+  }
+  if (field.required) {
+    schema = schema.min(1, { message: "Email is required" });
+  }
+  const finalSchema = applyCustomValidation(schema, field, field.name);
+  if (!field.required) {
+    return makeOptional(finalSchema, "email");
+  }
+  return finalSchema;
+}
+function createPasswordFieldSchema(field) {
+  let schema = z2.string();
+  if (field.minLength) {
+    schema = schema.min(field.minLength, {
+      message: `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`
+    });
+  }
+  if (field.required) {
+    schema = schema.min(1, { message: "Password is required" });
+  }
+  const finalSchema = applyCustomValidation(schema, field, field.name);
+  if (!field.required) {
+    return makeOptional(finalSchema, "password");
+  }
+  return finalSchema;
+}
+
+// src/schema/builders/number.ts
+import { z as z3 } from "zod";
+function createNumberFieldSchema(field) {
+  let numSchema = z3.number({ invalid_type_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 = z3.preprocess(coerceToNumber, numSchema);
+  schema = applyCustomValidation(schema, field, field.name);
+  if (field.required) {
+    return schema;
+  }
+  return makeOptional(schema, "number");
+}
+
+// src/schema/builders/date.ts
+import { z as z4 } from "zod";
+function toDate(value) {
+  if (!value) return void 0;
+  if (value instanceof Date) return isNaN(value.getTime()) ? void 0 : value;
+  const parsed = new Date(value);
+  return isNaN(parsed.getTime()) ? void 0 : parsed;
+}
+function createDateFieldSchema(field) {
+  const isDatetime = field.type === "datetime";
+  const minDate = toDate(field.minDate);
+  const maxDate = toDate(field.maxDate);
+  let dateSchema = z4.date({ invalid_type_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}`
+    });
+  }
+  if (maxDate) {
+    const formattedDate = isDatetime ? maxDate.toLocaleString() : maxDate.toDateString();
+    dateSchema = dateSchema.max(maxDate, {
+      message: `Date must be on or before ${formattedDate}`
+    });
+  }
+  let schema = z4.preprocess(coerceToDate, dateSchema);
+  schema = applyCustomValidation(schema, field, field.name);
+  if (field.required) {
+    return schema.refine(
+      (val) => val instanceof Date && !isNaN(val.getTime()),
+      "Date is required"
+    );
+  }
+  return makeOptional(schema, "date");
+}
+
+// src/schema/builders/select.ts
+import { z as z5 } from "zod";
+var selectValueSchema = z5.union([z5.string(), z5.number(), z5.boolean()]);
+function createSelectFieldSchema(field) {
+  if (field.hasMany) {
+    let arraySchema = z5.array(selectValueSchema);
+    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 schema2;
+  }
+  let schema = selectValueSchema;
+  if (field.required) {
+    schema = selectValueSchema.refine(
+      (val) => val !== "" && val !== null && val !== void 0,
+      "Please select an option"
+    );
+  }
+  schema = applyCustomValidation(schema, field, field.name);
+  if (!field.required) {
+    return makeOptional(schema, "select");
+  }
+  return schema;
+}
+function createRadioFieldSchema(field) {
+  let schema = selectValueSchema;
+  if (field.required) {
+    schema = selectValueSchema.refine(
+      (val) => val !== "" && val !== null && val !== void 0,
+      "Please select an option"
+    );
+  }
+  schema = applyCustomValidation(schema, field, field.name);
+  if (!field.required) {
+    return makeOptional(schema, "radio");
+  }
+  return schema;
+}
+
+// src/schema/builders/boolean.ts
+import { z as z6 } from "zod";
+function createCheckboxFieldSchema(field) {
+  let schema = z6.boolean();
+  if (field.required) {
+    schema = z6.boolean().refine((val) => val === true, {
+      message: "This field is required"
+    });
+  }
+  return applyCustomValidation(schema, field, field.name);
+}
+function createSwitchFieldSchema(field) {
+  let schema = z6.boolean();
+  if (field.required) {
+    schema = z6.boolean().refine((val) => val === true, {
+      message: "This field is required"
+    });
+  }
+  return applyCustomValidation(schema, field, field.name);
+}
+
+// src/schema/builders/upload.ts
+import { z as z7 } from "zod";
+function validateSingleFile(value, field) {
+  if (value === null || value === void 0 || value === "") {
+    return { valid: true };
+  }
+  if (typeof value === "string") {
+    return { valid: true };
+  }
+  if (!isFileLike(value)) {
+    return { valid: false, message: "Invalid file" };
+  }
+  if (field.maxSize && value.size > field.maxSize) {
+    const sizeMB = (field.maxSize / 1024 / 1024).toFixed(1);
+    return {
+      valid: false,
+      message: `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}`
+      };
+    }
+  }
+  return { valid: true };
+}
+function createUploadFieldSchema(field) {
+  if (field.hasMany) {
+    const schema2 = z7.array(z7.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: z7.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: z7.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: z7.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: z7.ZodIssueCode.custom,
+            message: `Maximum ${field.maxFiles} file(s) allowed`
+          });
+        }
+      }
+    });
+    if (!field.required) {
+      return schema2.optional().default([]);
+    }
+    return schema2;
+  }
+  const schema = z7.any().superRefine((value, ctx) => {
+    if (field.required && (value === null || value === void 0 || value === "")) {
+      ctx.addIssue({
+        code: z7.ZodIssueCode.custom,
+        message: "File is required"
+      });
+      return;
+    }
+    if (value === null || value === void 0 || value === "") {
+      return;
+    }
+    const result = validateSingleFile(value, field);
+    if (!result.valid) {
+      ctx.addIssue({
+        code: z7.ZodIssueCode.custom,
+        message: result.message || "Invalid file"
+      });
+    }
+  });
+  if (!field.required) {
+    return schema.optional().nullable();
+  }
+  return schema;
+}
+
+// src/schema/builders/tags.ts
+import { z as z8 } from "zod";
+function createTagsFieldSchema(field) {
+  const tagSchema = z8.string();
+  let schema = z8.array(tagSchema);
+  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(
+      (arr) => Array.isArray(arr) && arr.length > 0,
+      "At least one tag is required"
+    );
+    return finalSchema;
+  }
+  return finalSchema.optional().default([]);
+}
+
+// src/schema/builders/composite.ts
+import { z as z9 } from "zod";
+function createArrayFieldSchema(field, fieldsToZodSchema2) {
+  const itemSchema = fieldsToZodSchema2(field.fields);
+  let schema = z9.array(itemSchema);
+  if (field.minRows !== void 0) {
+    schema = schema.min(
+      field.minRows,
+      `At least ${field.minRows} row${field.minRows !== 1 ? "s" : ""} required`
+    );
+  }
+  if (field.maxRows !== void 0) {
+    schema = schema.max(
+      field.maxRows,
+      `Maximum ${field.maxRows} row${field.maxRows !== 1 ? "s" : ""} allowed`
+    );
+  }
+  if (field.required) {
+    return schema;
+  }
+  return schema.optional().default([]);
+}
+function createGroupFieldSchema(field, fieldsToZodSchema2) {
+  const schema = fieldsToZodSchema2(field.fields);
+  if (!field.required) {
+    return schema.optional();
+  }
+  return schema;
+}
+
+// src/schema/fields-to-schema.ts
+function fieldToZod(field) {
+  if ("schema" in field && field.schema) {
+    return field.schema;
+  }
+  switch (field.type) {
+    // Text-based fields
+    case "text":
+      return createTextFieldSchema(field);
+    case "email":
+      return createEmailFieldSchema(field);
+    case "password":
+      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":
+      return z10.any();
+    default:
+      return z10.any();
+  }
+}
+function processTabsField(field) {
+  const shape = {};
+  for (const tab of field.tabs) {
+    if (tab.name) {
+      const tabSchema = fieldsToZodSchema(tab.fields);
+      shape[tab.name] = tabSchema;
+    } else {
+      const tabFieldsSchema = fieldsToZodSchema(tab.fields);
+      if (tabFieldsSchema instanceof z10.ZodObject) {
+        Object.assign(shape, tabFieldsSchema.shape);
+      }
+    }
+  }
+  return shape;
+}
+function fieldsToZodSchema(fields) {
+  const shape = {};
+  for (const field of fields) {
+    if ("name" in field && field.name) {
+      shape[field.name] = fieldToZod(field);
+    } else if (field.type === "tabs") {
+      const tabsShape = processTabsField(field);
+      Object.assign(shape, tabsShape);
+    } else if (field.type === "row" || field.type === "collapsible") {
+      const nestedSchema = fieldsToZodSchema(field.fields);
+      if (nestedSchema instanceof z10.ZodObject) {
+        Object.assign(shape, nestedSchema.shape);
+      }
+    }
+  }
+  return z10.object(shape);
+}
+
+// src/schema/create-schema.ts
+function createSchema(fields) {
+  const schema = fieldsToZodSchema(fields);
+  return Object.assign(schema, { fields });
+}
+
+export {
+  extractValidationConfig,
+  applyCustomValidation,
+  makeOptional,
+  coerceToNumber,
+  coerceToDate,
+  getPatternErrorMessage,
+  isFileLike,
+  isFileTypeAccepted,
+  createTextFieldSchema,
+  createEmailFieldSchema,
+  createPasswordFieldSchema,
+  createNumberFieldSchema,
+  createDateFieldSchema,
+  createSelectFieldSchema,
+  createRadioFieldSchema,
+  createCheckboxFieldSchema,
+  createSwitchFieldSchema,
+  createUploadFieldSchema,
+  createTagsFieldSchema,
+  createArrayFieldSchema,
+  createGroupFieldSchema,
+  fieldsToZodSchema,
+  createSchema
+};
+//# sourceMappingURL=chunk-K42S5YX3.mjs.map