@buildnbuzz/buzzform 0.1.0

package/dist/index.js

@@ -0,0 +1,1028 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  FormConfigContext: () => FormConfigContext,
+  FormProvider: () => FormProvider,
+  applyCustomValidation: () => applyCustomValidation,
+  applyNumericPrecision: () => applyNumericPrecision,
+  clampNumber: () => clampNumber,
+  coerceToDate: () => coerceToDate,
+  coerceToNumber: () => coerceToNumber,
+  countNestedErrors: () => countNestedErrors,
+  createArrayHelpers: () => createArrayHelpers,
+  createSchema: () => createSchema,
+  extractValidationConfig: () => extractValidationConfig,
+  fieldsToZodSchema: () => fieldsToZodSchema,
+  formatBytes: () => formatBytes,
+  formatNumberWithSeparator: () => formatNumberWithSeparator,
+  generateFieldId: () => generateFieldId,
+  getArrayRowLabel: () => getArrayRowLabel,
+  getFieldWidthStyle: () => getFieldWidthStyle,
+  getNestedFieldPaths: () => getNestedFieldPaths,
+  getNestedValue: () => getNestedValue,
+  getPatternErrorMessage: () => getPatternErrorMessage,
+  getSelectOptionLabel: () => getSelectOptionLabel,
+  getSelectOptionLabelString: () => getSelectOptionLabelString,
+  getSelectOptionValue: () => getSelectOptionValue,
+  isFileLike: () => isFileLike,
+  isFileTypeAccepted: () => isFileTypeAccepted,
+  isSelectOptionDisabled: () => isSelectOptionDisabled,
+  makeOptional: () => makeOptional,
+  normalizeSelectOption: () => normalizeSelectOption,
+  parseFormattedNumber: () => parseFormattedNumber,
+  parseToDate: () => parseToDate,
+  resolveFieldState: () => resolveFieldState,
+  setNestedValue: () => setNestedValue,
+  useForm: () => useForm,
+  validateAdapter: () => validateAdapter
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/types/adapter.ts
+function validateAdapter(adapter, adapterName = "adapter") {
+  const required = [
+    "control",
+    "formState",
+    "handleSubmit",
+    "getValues",
+    "setValue",
+    "reset",
+    "watch",
+    "validate",
+    "setError",
+    "clearErrors",
+    "array"
+  ];
+  for (const key of required) {
+    if (adapter[key] === void 0) {
+      throw new Error(
+        `Invalid FormAdapter: "${adapterName}" is missing required property "${key}". See FormAdapter interface for implementation requirements.`
+      );
+    }
+  }
+  const arrayMethods = [
+    "fields",
+    "append",
+    "prepend",
+    "insert",
+    "remove",
+    "move",
+    "swap",
+    "replace",
+    "update"
+  ];
+  for (const method of arrayMethods) {
+    if (typeof adapter.array[method] !== "function") {
+      throw new Error(
+        `Invalid FormAdapter: "${adapterName}.array.${method}" must be a function.`
+      );
+    }
+  }
+}
+
+// src/schema/fields-to-schema.ts
+var import_zod10 = require("zod");
+
+// src/schema/builders/text.ts
+var import_zod2 = require("zod");
+
+// src/schema/helpers.ts
+var import_zod = require("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: 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();
+  }
+}
+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 = import_zod2.z.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 = import_zod2.z.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 = import_zod2.z.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 = import_zod2.z.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
+var import_zod3 = require("zod");
+function createNumberFieldSchema(field) {
+  let numSchema = import_zod3.z.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 = import_zod3.z.preprocess(coerceToNumber, numSchema);
+  schema = applyCustomValidation(schema, field, field.name);
+  if (field.required) {
+    return schema;
+  }
+  return makeOptional(schema, "number");
+}
+
+// src/schema/builders/date.ts
+var import_zod4 = require("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 = import_zod4.z.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 = import_zod4.z.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
+var import_zod5 = require("zod");
+var selectValueSchema = import_zod5.z.union([import_zod5.z.string(), import_zod5.z.number(), import_zod5.z.boolean()]);
+function createSelectFieldSchema(field) {
+  if (field.hasMany) {
+    let arraySchema = import_zod5.z.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
+var import_zod6 = require("zod");
+function createCheckboxFieldSchema(field) {
+  let schema = import_zod6.z.boolean();
+  if (field.required) {
+    schema = import_zod6.z.boolean().refine((val) => val === true, {
+      message: "This field is required"
+    });
+  }
+  return applyCustomValidation(schema, field, field.name);
+}
+function createSwitchFieldSchema(field) {
+  let schema = import_zod6.z.boolean();
+  if (field.required) {
+    schema = import_zod6.z.boolean().refine((val) => val === true, {
+      message: "This field is required"
+    });
+  }
+  return applyCustomValidation(schema, field, field.name);
+}
+
+// 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 };
+  }
+  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 = 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"
+      });
+      return;
+    }
+    if (value === null || value === void 0 || value === "") {
+      return;
+    }
+    const result = validateSingleFile(value, field);
+    if (!result.valid) {
+      ctx.addIssue({
+        code: import_zod7.z.ZodIssueCode.custom,
+        message: result.message || "Invalid file"
+      });
+    }
+  });
+  if (!field.required) {
+    return schema.optional().nullable();
+  }
+  return schema;
+}
+
+// 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);
+  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
+var import_zod9 = require("zod");
+function createArrayFieldSchema(field, fieldsToZodSchema2) {
+  const itemSchema = fieldsToZodSchema2(field.fields);
+  let schema = import_zod9.z.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 import_zod10.z.any();
+    default:
+      return import_zod10.z.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 import_zod10.z.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 import_zod10.z.ZodObject) {
+        Object.assign(shape, nestedSchema.shape);
+      }
+    }
+  }
+  return import_zod10.z.object(shape);
+}
+
+// src/schema/create-schema.ts
+function createSchema(fields) {
+  const schema = fieldsToZodSchema(fields);
+  return Object.assign(schema, { fields });
+}
+
+// src/utils/array.ts
+var import_nanoid = require("nanoid");
+function createArrayHelpers(getArray, setArray) {
+  return {
+    fields: (path) => {
+      const arr = getArray(path);
+      if (!Array.isArray(arr)) return [];
+      return arr.map((item, index) => ({
+        id: item?.id || `${path}-${index}`,
+        ...item
+      }));
+    },
+    append: (path, value) => {
+      const current = getArray(path) || [];
+      const itemWithId = ensureId(value);
+      setArray(path, [...current, itemWithId]);
+    },
+    prepend: (path, value) => {
+      const current = getArray(path) || [];
+      const itemWithId = ensureId(value);
+      setArray(path, [itemWithId, ...current]);
+    },
+    insert: (path, index, value) => {
+      const current = [...getArray(path) || []];
+      const itemWithId = ensureId(value);
+      current.splice(index, 0, itemWithId);
+      setArray(path, current);
+    },
+    remove: (path, index) => {
+      const current = [...getArray(path) || []];
+      current.splice(index, 1);
+      setArray(path, current);
+    },
+    move: (path, from, to) => {
+      const current = [...getArray(path) || []];
+      const [item] = current.splice(from, 1);
+      current.splice(to, 0, item);
+      setArray(path, current);
+    },
+    swap: (path, indexA, indexB) => {
+      const current = [...getArray(path) || []];
+      const temp = current[indexA];
+      current[indexA] = current[indexB];
+      current[indexB] = temp;
+      setArray(path, current);
+    },
+    replace: (path, values) => {
+      const itemsWithIds = values.map(ensureId);
+      setArray(path, itemsWithIds);
+    },
+    update: (path, index, value) => {
+      const current = [...getArray(path) || []];
+      const existingId = current[index]?.id;
+      current[index] = {
+        ...typeof value === "object" && value !== null ? value : {},
+        id: existingId || (0, import_nanoid.nanoid)()
+      };
+      setArray(path, current);
+    }
+  };
+}
+function ensureId(value) {
+  if (typeof value === "object" && value !== null) {
+    const obj = value;
+    if (!obj.id) {
+      return { ...obj, id: (0, import_nanoid.nanoid)() };
+    }
+    return obj;
+  }
+  return { value, id: (0, import_nanoid.nanoid)() };
+}
+
+// src/lib/utils.ts
+function generateFieldId(path) {
+  return `field-${path.replace(/\./g, "-").replace(/\[/g, "-").replace(/\]/g, "")}`;
+}
+function getNestedValue(obj, path) {
+  if (!obj || !path) return void 0;
+  return path.split(".").reduce((acc, key) => {
+    if (acc && typeof acc === "object" && acc !== null) {
+      return acc[key];
+    }
+    return void 0;
+  }, obj);
+}
+function setNestedValue(obj, path, value) {
+  const keys = path.split(".");
+  const result = { ...obj };
+  let current = result;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (!(key in current) || typeof current[key] !== "object") {
+      const nextKey = keys[i + 1];
+      current[key] = /^\d+$/.test(nextKey) ? [] : {};
+    } else {
+      current[key] = Array.isArray(current[key]) ? [...current[key]] : { ...current[key] };
+    }
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = value;
+  return result;
+}
+function formatBytes(bytes, decimals = 2) {
+  if (bytes === 0) return "0 Bytes";
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
+}
+
+// src/lib/field.ts
+function getNestedFieldPaths(fields, basePath) {
+  const paths = [];
+  for (const field of fields) {
+    if ("name" in field && field.name) {
+      const fieldPath = basePath ? `${basePath}.${field.name}` : field.name;
+      paths.push(fieldPath);
+      if (field.type === "group" && "fields" in field) {
+        paths.push(...getNestedFieldPaths(field.fields, fieldPath));
+      }
+      if (field.type === "array" && "fields" in field) {
+        paths.push(...getNestedFieldPaths(field.fields, fieldPath));
+      }
+    }
+    if ("fields" in field && field.type !== "group" && field.type !== "array") {
+      const layoutField = field;
+      paths.push(...getNestedFieldPaths(layoutField.fields, basePath));
+    }
+    if (field.type === "tabs" && "tabs" in field) {
+      for (const tab of field.tabs) {
+        const tabPath = tab.name ? basePath ? `${basePath}.${tab.name}` : tab.name : basePath;
+        paths.push(...getNestedFieldPaths(tab.fields, tabPath));
+      }
+    }
+  }
+  return paths;
+}
+function countNestedErrors(errors, fields, basePath) {
+  const paths = getNestedFieldPaths(fields, basePath);
+  return paths.filter((path) => errors[path]).length;
+}
+function resolveFieldState(value, formData, siblingData = formData) {
+  if (typeof value === "function") {
+    return value(formData, siblingData);
+  }
+  return Boolean(value);
+}
+function getArrayRowLabel(rowData, fields, uiOptions, fallbackLabel) {
+  if (uiOptions?.rowLabelField && rowData?.[uiOptions.rowLabelField]) {
+    return String(rowData[uiOptions.rowLabelField]);
+  }
+  const firstNamedField = fields.find((f) => "name" in f && f.name);
+  if (firstNamedField && "name" in firstNamedField) {
+    const value = rowData?.[firstNamedField.name];
+    if (value) {
+      return String(value);
+    }
+  }
+  return fallbackLabel;
+}
+function getFieldWidthStyle(style) {
+  if (!style?.width) return void 0;
+  return {
+    width: typeof style.width === "number" ? `${style.width}px` : style.width
+  };
+}
+function normalizeSelectOption(option) {
+  if (typeof option === "string") {
+    return { value: option, label: option };
+  }
+  return {
+    value: option.value,
+    label: option.label ?? String(option.value),
+    description: option.description,
+    icon: option.icon,
+    disabled: option.disabled
+  };
+}
+function getSelectOptionValue(option) {
+  if (typeof option === "string") return option;
+  const val = option.value;
+  if (typeof val === "boolean") return val ? "true" : "false";
+  return String(val);
+}
+function getSelectOptionLabel(option) {
+  if (typeof option === "string") return option;
+  return option.label ?? String(option.value);
+}
+function getSelectOptionLabelString(option) {
+  if (typeof option === "string") return option;
+  if (typeof option.label === "string") return option.label;
+  return String(option.value);
+}
+function isSelectOptionDisabled(option) {
+  if (typeof option === "string") return false;
+  return option.disabled === true;
+}
+function clampNumber(value, min, max) {
+  let result = value;
+  if (min !== void 0 && result < min) result = min;
+  if (max !== void 0 && result > max) result = max;
+  return result;
+}
+function applyNumericPrecision(value, precision) {
+  if (value === void 0 || precision === void 0) return value;
+  return parseFloat(value.toFixed(precision));
+}
+function formatNumberWithSeparator(value, separator = ",") {
+  if (value === void 0 || value === null || isNaN(value)) return "";
+  const [intPart, decPart] = value.toString().split(".");
+  const formattedInt = intPart.replace(/\B(?=(\d{3})+(?!\d))/g, separator);
+  return decPart !== void 0 ? `${formattedInt}.${decPart}` : formattedInt;
+}
+function parseFormattedNumber(str, separator = ",") {
+  if (!str || str === "") return void 0;
+  const cleaned = str.split(separator).join("");
+  const num = parseFloat(cleaned);
+  return isNaN(num) ? void 0 : num;
+}
+function parseToDate(value) {
+  if (!value) return void 0;
+  if (value instanceof Date) {
+    return isNaN(value.getTime()) ? void 0 : value;
+  }
+  if (typeof value === "number") {
+    const date = new Date(value);
+    return isNaN(date.getTime()) ? void 0 : date;
+  }
+  if (typeof value === "string") {
+    const date = new Date(value);
+    return isNaN(date.getTime()) ? void 0 : date;
+  }
+  return void 0;
+}
+
+// src/context/form-context.ts
+var import_react = require("react");
+var FormConfigContext = (0, import_react.createContext)(null);
+
+// src/providers/form-provider.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var FormProvider = ({ children, ...config }) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FormConfigContext.Provider, { value: config, children });
+};
+
+// src/hooks/use-form.ts
+var import_react2 = require("react");
+function extractDefaultsFromFields(fields) {
+  if (!fields || fields.length === 0) return void 0;
+  const defaults = {};
+  let hasDefaults = false;
+  for (const field of fields) {
+    if ("name" in field && "defaultValue" in field && field.defaultValue !== void 0) {
+      defaults[field.name] = field.defaultValue;
+      hasDefaults = true;
+    }
+    if ("fields" in field && Array.isArray(field.fields)) {
+      const nestedDefaults = extractDefaultsFromFields(field.fields);
+      if (nestedDefaults) {
+        Object.assign(defaults, nestedDefaults);
+        hasDefaults = true;
+      }
+    }
+  }
+  return hasDefaults ? defaults : void 0;
+}
+function applySettings(form, settings) {
+  if (!settings) return form;
+  if (settings.submitOnlyWhenDirty) {
+    const originalHandleSubmit = form.handleSubmit;
+    form.handleSubmit = (e) => {
+      if (!form.formState.isDirty) {
+        e?.preventDefault?.();
+        return;
+      }
+      return originalHandleSubmit(e);
+    };
+  }
+  if (settings) {
+    form.settings = settings;
+  }
+  return form;
+}
+function useForm(options) {
+  const globalConfig = (0, import_react2.useContext)(FormConfigContext);
+  if (!options.schema) {
+    throw new Error(
+      "useForm: schema is required. Use createSchema([...]) to create a schema from fields, or pass a Zod schema directly."
+    );
+  }
+  const adapter = options.adapter ?? globalConfig?.adapter;
+  const resolverFn = globalConfig?.resolver;
+  const mode = options.mode ?? globalConfig?.mode ?? "onChange";
+  const reValidateMode = options.reValidateMode ?? globalConfig?.reValidateMode ?? "onChange";
+  if (!adapter) {
+    throw new Error(
+      "useForm: No adapter configured. Either wrap your app in <FormProvider adapter={...}> or pass adapter in options."
+    );
+  }
+  const resolver = resolverFn ? resolverFn(options.schema) : void 0;
+  const schemaWithFields = options.schema;
+  const fieldDefaults = (0, import_react2.useMemo)(
+    () => extractDefaultsFromFields(schemaWithFields.fields),
+    [schemaWithFields.fields]
+  );
+  const defaultValues = options.defaultValues ?? fieldDefaults;
+  const form = adapter({
+    defaultValues,
+    resolver,
+    mode,
+    reValidateMode,
+    onSubmit: options.onSubmit
+  });
+  return applySettings(form, options.settings);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FormConfigContext,
+  FormProvider,
+  applyCustomValidation,
+  applyNumericPrecision,
+  clampNumber,
+  coerceToDate,
+  coerceToNumber,
+  countNestedErrors,
+  createArrayHelpers,
+  createSchema,
+  extractValidationConfig,
+  fieldsToZodSchema,
+  formatBytes,
+  formatNumberWithSeparator,
+  generateFieldId,
+  getArrayRowLabel,
+  getFieldWidthStyle,
+  getNestedFieldPaths,
+  getNestedValue,
+  getPatternErrorMessage,
+  getSelectOptionLabel,
+  getSelectOptionLabelString,
+  getSelectOptionValue,
+  isFileLike,
+  isFileTypeAccepted,
+  isSelectOptionDisabled,
+  makeOptional,
+  normalizeSelectOption,
+  parseFormattedNumber,
+  parseToDate,
+  resolveFieldState,
+  setNestedValue,
+  useForm,
+  validateAdapter
+});
+//# sourceMappingURL=index.js.map