pdyform 2.1.0 → 2.2.1

package/packages/core/dist/index.cjs

@@ -20,13 +20,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  applyFieldBlur: () => applyFieldBlur,
-  applyFieldChange: () => applyFieldChange,
-  createFormRuntimeState: () => createFormRuntimeState,
+  createFormStore: () => createFormStore,
+  defaultErrorMessages: () => defaultErrorMessages,
+  get: () => get,
   getDefaultValues: () => getDefaultValues,
   normalizeFieldValue: () => normalizeFieldValue,
-  runSubmitValidation: () => runSubmitValidation,
-  setSubmitting: () => setSubmitting,
+  set: () => set,
   validateField: () => validateField,
   validateFieldByName: () => validateFieldByName,
   validateForm: () => validateForm
@@ -40,85 +39,140 @@ function parseNumberish(value) {
   const parsed = Number(value);
   return Number.isNaN(parsed) ? null : parsed;
 }
+var defaultErrorMessages = {
+  required: "{label} is required",
+  min: "{label} must be at least {value}",
+  max: "{label} must be at most {value}",
+  email: "Invalid email address",
+  pattern: "Invalid format",
+  custom: "Invalid value"
+};
+function formatMessage(template, field, rule) {
+  return template.replace("{label}", field.label).replace("{value}", String(rule.value || ""));
+}
+function get(obj, path, defaultValue) {
+  if (!path) return defaultValue;
+  const keys = path.split(/[.[\]]/).filter(Boolean);
+  let result = obj;
+  for (const key of keys) {
+    if (result === null || result === void 0) return defaultValue;
+    result = result[key];
+  }
+  return result === void 0 ? defaultValue : result;
+}
+function set(obj, path, value) {
+  if (Object(obj) !== obj) return obj;
+  const keys = path.split(/[.[\]]/).filter(Boolean);
+  const newObj = { ...obj };
+  let current = newObj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    const nextKey = keys[i + 1];
+    const isNextKeyIndex = /^\d+$/.test(nextKey);
+    if (!(key in current) || current[key] === null || typeof current[key] !== "object") {
+      current[key] = isNextKeyIndex ? [] : {};
+    } else {
+      current[key] = Array.isArray(current[key]) ? [...current[key]] : { ...current[key] };
+    }
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = value;
+  return newObj;
+}
 function normalizeFieldValue(field, value) {
   if (field.type !== "number") return value;
   if (value === "" || value === void 0 || value === null) return "";
   const numericValue = parseNumberish(value);
   return numericValue === null ? value : numericValue;
 }
-function validateField(value, field) {
+async function validateField(value, field, customMessages) {
   if (!field.validations) return null;
+  const messages = { ...defaultErrorMessages, ...customMessages };
   for (const rule of field.validations) {
     switch (rule.type) {
       case "required":
         if (value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0) {
-          return rule.message || `${field.label} is required`;
+          return rule.message || formatMessage(messages.required, field, rule);
         }
         break;
       case "min":
         if (field.type === "number") {
           const numericValue = parseNumberish(value);
           if (numericValue !== null && numericValue < rule.value) {
-            return rule.message || `${field.label} must be at least ${rule.value}`;
+            const template = field.type === "number" ? messages.min : typeof value === "string" ? "{label} must be at least {value} characters" : messages.min;
+            return rule.message || formatMessage(template, field, rule);
           }
           break;
         }
         if (typeof value === "number" && value < rule.value) {
-          return rule.message || `${field.label} must be at least ${rule.value}`;
+          return rule.message || formatMessage(messages.min, field, rule);
         }
         if (typeof value === "string" && value.length < rule.value) {
-          return rule.message || `${field.label} must be at least ${rule.value} characters`;
+          const template = "{label} must be at least {value} characters";
+          return rule.message || formatMessage(template, field, rule);
         }
         break;
       case "max":
         if (field.type === "number") {
           const numericValue = parseNumberish(value);
           if (numericValue !== null && numericValue > rule.value) {
-            return rule.message || `${field.label} must be at most ${rule.value}`;
+            return rule.message || formatMessage(messages.max, field, rule);
           }
           break;
         }
         if (typeof value === "number" && value > rule.value) {
-          return rule.message || `${field.label} must be at most ${rule.value}`;
+          return rule.message || formatMessage(messages.max, field, rule);
         }
         if (typeof value === "string" && value.length > rule.value) {
-          return rule.message || `${field.label} must be at most ${rule.value} characters`;
+          const template = "{label} must be at most {value} characters";
+          return rule.message || formatMessage(template, field, rule);
         }
         break;
       case "email": {
         const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
         if (value && !emailRegex.test(value)) {
-          return rule.message || "Invalid email address";
+          return rule.message || formatMessage(messages.email, field, rule);
         }
         break;
       }
       case "pattern":
         if (value && rule.value && !new RegExp(rule.value).test(value)) {
-          return rule.message || "Invalid format";
+          return rule.message || formatMessage(messages.pattern, field, rule);
         }
         break;
       case "custom":
         if (rule.validator) {
-          const result = rule.validator(value);
+          const result = await rule.validator(value);
           if (typeof result === "string") return result;
-          if (!result) return rule.message || "Invalid value";
+          if (result === false) return rule.message || formatMessage(messages.custom, field, rule);
         }
         break;
     }
   }
   return null;
 }
-function validateFieldByName(fields, name, value) {
+async function validateFieldByName(fields, name, value, resolver, allValues, customMessages) {
+  if (resolver && allValues) {
+    const resolverErrors = await resolver(allValues);
+    if (resolverErrors[name]) return resolverErrors[name];
+  }
   const field = fields.find((f) => f.name === name);
   if (!field) return null;
-  return validateField(value, field);
+  return await validateField(value, field, customMessages);
 }
-function validateForm(fields, values) {
-  const errors = {};
-  for (const field of fields) {
-    const error = validateField(values[field.name], field);
-    if (error) errors[field.name] = error;
+async function validateForm(fields, values, resolver, customMessages) {
+  let errors = {};
+  if (resolver) {
+    errors = await resolver(values);
   }
+  const validationPromises = fields.map(async (field) => {
+    if (errors[field.name]) return;
+    const isHidden = typeof field.hidden === "function" ? field.hidden(values) : field.hidden;
+    if (isHidden) return;
+    const error = await validateField(get(values, field.name), field, customMessages);
+    if (error) errors[field.name] = error;
+  });
+  await Promise.all(validationPromises);
   return errors;
 }
 function getDefaultValues(fields) {
@@ -129,68 +183,82 @@ function getDefaultValues(fields) {
 }
 
 // src/formState.ts
-function createFormRuntimeState(fields) {
-  return {
+var import_vanilla = require("zustand/vanilla");
+function createFormStore(fields, resolver, errorMessages) {
+  return (0, import_vanilla.createStore)()((set2, getStore) => ({
     values: getDefaultValues(fields),
     errors: {},
-    isSubmitting: false
-  };
-}
-function setSubmitting(state, isSubmitting) {
-  return {
-    ...state,
-    isSubmitting
-  };
-}
-function applyFieldChange(fields, state, name, rawValue) {
-  const field = fields.find((f) => f.name === name);
-  const normalizedValue = field ? normalizeFieldValue(field, rawValue) : rawValue;
-  const values = {
-    ...state.values,
-    [name]: normalizedValue
-  };
-  const error = validateFieldByName(fields, name, normalizedValue);
-  const errors = {
-    ...state.errors,
-    [name]: error || ""
-  };
-  return {
-    ...state,
-    values,
-    errors
-  };
-}
-function applyFieldBlur(fields, state, name) {
-  const error = validateFieldByName(fields, name, state.values[name]);
-  return {
-    ...state,
-    errors: {
-      ...state.errors,
-      [name]: error || ""
-    }
-  };
-}
-function runSubmitValidation(fields, state) {
-  const errors = validateForm(fields, state.values);
-  const hasError = Object.keys(errors).length > 0;
-  return {
-    state: {
-      ...state,
-      errors,
-      isSubmitting: false
+    validatingFields: [],
+    isSubmitting: false,
+    setFieldValue: async (name, rawValue) => {
+      const field = fields.find((f) => f.name === name);
+      const normalizedValue = field ? normalizeFieldValue(field, rawValue) : rawValue;
+      set2((state) => ({
+        values: set(state.values, name, normalizedValue)
+      }));
+      const hasExistingError = !!getStore().errors[name];
+      const shouldValidateImmediately = field && ["select", "checkbox", "radio", "switch", "date"].includes(field.type);
+      if (shouldValidateImmediately || hasExistingError) {
+        set2((state) => ({
+          validatingFields: [...state.validatingFields, name]
+        }));
+        try {
+          const currentValues = getStore().values;
+          const error = await validateFieldByName(fields, name, normalizedValue, resolver, currentValues, errorMessages);
+          set2((state) => ({
+            errors: { ...state.errors, [name]: error || "" },
+            validatingFields: state.validatingFields.filter((f) => f !== name)
+          }));
+        } catch (err) {
+          set2((state) => ({
+            validatingFields: state.validatingFields.filter((f) => f !== name)
+          }));
+        }
+      }
     },
-    hasError
-  };
+    setFieldBlur: async (name) => {
+      set2((state) => ({
+        validatingFields: [...state.validatingFields, name]
+      }));
+      try {
+        const currentValues = getStore().values;
+        const value = get(currentValues, name);
+        const error = await validateFieldByName(fields, name, value, resolver, currentValues, errorMessages);
+        set2((state) => ({
+          errors: { ...state.errors, [name]: error || "" },
+          validatingFields: state.validatingFields.filter((f) => f !== name)
+        }));
+      } catch (err) {
+        set2((state) => ({
+          validatingFields: state.validatingFields.filter((f) => f !== name)
+        }));
+      }
+    },
+    setSubmitting: (isSubmitting) => set2({ isSubmitting }),
+    runSubmitValidation: async () => {
+      set2({ isSubmitting: true });
+      const state = getStore();
+      const errors = await validateForm(fields, state.values, resolver, errorMessages);
+      const hasError = Object.keys(errors).length > 0;
+      set2({
+        errors,
+        isSubmitting: false
+      });
+      return {
+        state: getStore(),
+        hasError
+      };
+    }
+  }));
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  applyFieldBlur,
-  applyFieldChange,
-  createFormRuntimeState,
+  createFormStore,
+  defaultErrorMessages,
+  get,
   getDefaultValues,
   normalizeFieldValue,
-  runSubmitValidation,
-  setSubmitting,
+  set,
   validateField,
   validateFieldByName,
   validateForm

package/packages/core/dist/index.d.cts

@@ -1,3 +1,4 @@
-export { FieldType, FormField, FormSchema, FormState, Option, ValidationRule } from './types.cjs';
-export { getDefaultValues, normalizeFieldValue, validateField, validateFieldByName, validateForm } from './utils.cjs';
-export { FormRuntimeState, applyFieldBlur, applyFieldChange, createFormRuntimeState, runSubmitValidation, setSubmitting } from './formState.cjs';
+export { ErrorMessageTemplates, FieldType, FormField, FormResolver, FormSchema, FormState, Option, ValidationRule } from './types.cjs';
+export { defaultErrorMessages, get, getDefaultValues, normalizeFieldValue, set, validateField, validateFieldByName, validateForm } from './utils.cjs';
+export { FormRuntimeState, FormStore, createFormStore } from './formState.cjs';
+import 'zustand/vanilla';

package/packages/core/dist/index.d.ts

@@ -1,3 +1,4 @@
-export { FieldType, FormField, FormSchema, FormState, Option, ValidationRule } from './types.js';
-export { getDefaultValues, normalizeFieldValue, validateField, validateFieldByName, validateForm } from './utils.js';
-export { FormRuntimeState, applyFieldBlur, applyFieldChange, createFormRuntimeState, runSubmitValidation, setSubmitting } from './formState.js';
+export { ErrorMessageTemplates, FieldType, FormField, FormResolver, FormSchema, FormState, Option, ValidationRule } from './types.js';
+export { defaultErrorMessages, get, getDefaultValues, normalizeFieldValue, set, validateField, validateFieldByName, validateForm } from './utils.js';
+export { FormRuntimeState, FormStore, createFormStore } from './formState.js';
+import 'zustand/vanilla';

package/packages/core/dist/index.js

@@ -1,25 +1,24 @@
 import {
-  applyFieldBlur,
-  applyFieldChange,
-  createFormRuntimeState,
-  runSubmitValidation,
-  setSubmitting
-} from "./chunk-TP3IHKWV.js";
+  createFormStore
+} from "./chunk-J6ESJZ4U.js";
+import "./chunk-6F4PWJZI.js";
 import {
+  defaultErrorMessages,
+  get,
   getDefaultValues,
   normalizeFieldValue,
+  set,
   validateField,
   validateFieldByName,
   validateForm
-} from "./chunk-WEDHXOHH.js";
+} from "./chunk-B7OMM2UC.js";
 export {
-  applyFieldBlur,
-  applyFieldChange,
-  createFormRuntimeState,
+  createFormStore,
+  defaultErrorMessages,
+  get,
   getDefaultValues,
   normalizeFieldValue,
-  runSubmitValidation,
-  setSubmitting,
+  set,
   validateField,
   validateFieldByName,
   validateForm

package/packages/core/dist/types.d.cts

@@ -1,9 +1,9 @@
-type FieldType = 'text' | 'number' | 'email' | 'password' | 'select' | 'checkbox' | 'radio' | 'textarea' | 'date';
+type FieldType = 'text' | 'number' | 'email' | 'password' | 'select' | 'checkbox' | 'radio' | 'textarea' | 'date' | 'switch';
 interface ValidationRule {
     type: 'required' | 'min' | 'max' | 'pattern' | 'email' | 'custom';
     value?: any;
     message?: string;
-    validator?: (value: any) => boolean | string;
+    validator?: (value: any) => boolean | string | Promise<boolean | string>;
 }
 interface Option {
     label: string;
@@ -19,21 +19,33 @@ interface FormField {
     defaultValue?: any;
     options?: Option[];
     validations?: ValidationRule[];
-    hidden?: boolean;
-    disabled?: boolean;
+    hidden?: boolean | ((values: any) => boolean);
+    disabled?: boolean | ((values: any) => boolean);
     className?: string;
 }
+type FormResolver = (values: any) => Record<string, string> | Promise<Record<string, string>>;
+type ErrorMessageTemplates = {
+    required?: string;
+    min?: string;
+    max?: string;
+    email?: string;
+    pattern?: string;
+    custom?: string;
+};
 interface FormSchema {
     title?: string;
     description?: string;
     fields: FormField[];
     submitButtonText?: string;
+    resolver?: FormResolver;
+    errorMessages?: ErrorMessageTemplates;
 }
 interface FormState {
     values: Record<string, any>;
     errors: Record<string, string>;
+    validatingFields: string[];
     isSubmitting: boolean;
     isValid: boolean;
 }
 
-export type { FieldType, FormField, FormSchema, FormState, Option, ValidationRule };
+export type { ErrorMessageTemplates, FieldType, FormField, FormResolver, FormSchema, FormState, Option, ValidationRule };

package/packages/core/dist/types.d.ts

@@ -1,9 +1,9 @@
-type FieldType = 'text' | 'number' | 'email' | 'password' | 'select' | 'checkbox' | 'radio' | 'textarea' | 'date';
+type FieldType = 'text' | 'number' | 'email' | 'password' | 'select' | 'checkbox' | 'radio' | 'textarea' | 'date' | 'switch';
 interface ValidationRule {
     type: 'required' | 'min' | 'max' | 'pattern' | 'email' | 'custom';
     value?: any;
     message?: string;
-    validator?: (value: any) => boolean | string;
+    validator?: (value: any) => boolean | string | Promise<boolean | string>;
 }
 interface Option {
     label: string;
@@ -19,21 +19,33 @@ interface FormField {
     defaultValue?: any;
     options?: Option[];
     validations?: ValidationRule[];
-    hidden?: boolean;
-    disabled?: boolean;
+    hidden?: boolean | ((values: any) => boolean);
+    disabled?: boolean | ((values: any) => boolean);
     className?: string;
 }
+type FormResolver = (values: any) => Record<string, string> | Promise<Record<string, string>>;
+type ErrorMessageTemplates = {
+    required?: string;
+    min?: string;
+    max?: string;
+    email?: string;
+    pattern?: string;
+    custom?: string;
+};
 interface FormSchema {
     title?: string;
     description?: string;
     fields: FormField[];
     submitButtonText?: string;
+    resolver?: FormResolver;
+    errorMessages?: ErrorMessageTemplates;
 }
 interface FormState {
     values: Record<string, any>;
     errors: Record<string, string>;
+    validatingFields: string[];
     isSubmitting: boolean;
     isValid: boolean;
 }
 
-export type { FieldType, FormField, FormSchema, FormState, Option, ValidationRule };
+export type { ErrorMessageTemplates, FieldType, FormField, FormResolver, FormSchema, FormState, Option, ValidationRule };

package/packages/core/dist/types.js

@@ -0,0 +1 @@
+import "./chunk-6F4PWJZI.js";

package/packages/core/dist/utils.cjs

@@ -20,8 +20,11 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/utils.ts
 var utils_exports = {};
 __export(utils_exports, {
+  defaultErrorMessages: () => defaultErrorMessages,
+  get: () => get,
   getDefaultValues: () => getDefaultValues,
   normalizeFieldValue: () => normalizeFieldValue,
+  set: () => set,
   validateField: () => validateField,
   validateFieldByName: () => validateFieldByName,
   validateForm: () => validateForm
@@ -33,85 +36,140 @@ function parseNumberish(value) {
   const parsed = Number(value);
   return Number.isNaN(parsed) ? null : parsed;
 }
+var defaultErrorMessages = {
+  required: "{label} is required",
+  min: "{label} must be at least {value}",
+  max: "{label} must be at most {value}",
+  email: "Invalid email address",
+  pattern: "Invalid format",
+  custom: "Invalid value"
+};
+function formatMessage(template, field, rule) {
+  return template.replace("{label}", field.label).replace("{value}", String(rule.value || ""));
+}
+function get(obj, path, defaultValue) {
+  if (!path) return defaultValue;
+  const keys = path.split(/[.[\]]/).filter(Boolean);
+  let result = obj;
+  for (const key of keys) {
+    if (result === null || result === void 0) return defaultValue;
+    result = result[key];
+  }
+  return result === void 0 ? defaultValue : result;
+}
+function set(obj, path, value) {
+  if (Object(obj) !== obj) return obj;
+  const keys = path.split(/[.[\]]/).filter(Boolean);
+  const newObj = { ...obj };
+  let current = newObj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    const nextKey = keys[i + 1];
+    const isNextKeyIndex = /^\d+$/.test(nextKey);
+    if (!(key in current) || current[key] === null || typeof current[key] !== "object") {
+      current[key] = isNextKeyIndex ? [] : {};
+    } else {
+      current[key] = Array.isArray(current[key]) ? [...current[key]] : { ...current[key] };
+    }
+    current = current[key];
+  }
+  current[keys[keys.length - 1]] = value;
+  return newObj;
+}
 function normalizeFieldValue(field, value) {
   if (field.type !== "number") return value;
   if (value === "" || value === void 0 || value === null) return "";
   const numericValue = parseNumberish(value);
   return numericValue === null ? value : numericValue;
 }
-function validateField(value, field) {
+async function validateField(value, field, customMessages) {
   if (!field.validations) return null;
+  const messages = { ...defaultErrorMessages, ...customMessages };
   for (const rule of field.validations) {
     switch (rule.type) {
       case "required":
         if (value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0) {
-          return rule.message || `${field.label} is required`;
+          return rule.message || formatMessage(messages.required, field, rule);
         }
         break;
       case "min":
         if (field.type === "number") {
           const numericValue = parseNumberish(value);
           if (numericValue !== null && numericValue < rule.value) {
-            return rule.message || `${field.label} must be at least ${rule.value}`;
+            const template = field.type === "number" ? messages.min : typeof value === "string" ? "{label} must be at least {value} characters" : messages.min;
+            return rule.message || formatMessage(template, field, rule);
           }
           break;
         }
         if (typeof value === "number" && value < rule.value) {
-          return rule.message || `${field.label} must be at least ${rule.value}`;
+          return rule.message || formatMessage(messages.min, field, rule);
         }
         if (typeof value === "string" && value.length < rule.value) {
-          return rule.message || `${field.label} must be at least ${rule.value} characters`;
+          const template = "{label} must be at least {value} characters";
+          return rule.message || formatMessage(template, field, rule);
         }
         break;
       case "max":
         if (field.type === "number") {
           const numericValue = parseNumberish(value);
           if (numericValue !== null && numericValue > rule.value) {
-            return rule.message || `${field.label} must be at most ${rule.value}`;
+            return rule.message || formatMessage(messages.max, field, rule);
           }
           break;
         }
         if (typeof value === "number" && value > rule.value) {
-          return rule.message || `${field.label} must be at most ${rule.value}`;
+          return rule.message || formatMessage(messages.max, field, rule);
         }
         if (typeof value === "string" && value.length > rule.value) {
-          return rule.message || `${field.label} must be at most ${rule.value} characters`;
+          const template = "{label} must be at most {value} characters";
+          return rule.message || formatMessage(template, field, rule);
         }
         break;
       case "email": {
         const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
         if (value && !emailRegex.test(value)) {
-          return rule.message || "Invalid email address";
+          return rule.message || formatMessage(messages.email, field, rule);
         }
         break;
       }
       case "pattern":
         if (value && rule.value && !new RegExp(rule.value).test(value)) {
-          return rule.message || "Invalid format";
+          return rule.message || formatMessage(messages.pattern, field, rule);
         }
         break;
       case "custom":
         if (rule.validator) {
-          const result = rule.validator(value);
+          const result = await rule.validator(value);
           if (typeof result === "string") return result;
-          if (!result) return rule.message || "Invalid value";
+          if (result === false) return rule.message || formatMessage(messages.custom, field, rule);
         }
         break;
     }
   }
   return null;
 }
-function validateFieldByName(fields, name, value) {
+async function validateFieldByName(fields, name, value, resolver, allValues, customMessages) {
+  if (resolver && allValues) {
+    const resolverErrors = await resolver(allValues);
+    if (resolverErrors[name]) return resolverErrors[name];
+  }
   const field = fields.find((f) => f.name === name);
   if (!field) return null;
-  return validateField(value, field);
+  return await validateField(value, field, customMessages);
 }
-function validateForm(fields, values) {
-  const errors = {};
-  for (const field of fields) {
-    const error = validateField(values[field.name], field);
-    if (error) errors[field.name] = error;
+async function validateForm(fields, values, resolver, customMessages) {
+  let errors = {};
+  if (resolver) {
+    errors = await resolver(values);
   }
+  const validationPromises = fields.map(async (field) => {
+    if (errors[field.name]) return;
+    const isHidden = typeof field.hidden === "function" ? field.hidden(values) : field.hidden;
+    if (isHidden) return;
+    const error = await validateField(get(values, field.name), field, customMessages);
+    if (error) errors[field.name] = error;
+  });
+  await Promise.all(validationPromises);
   return errors;
 }
 function getDefaultValues(fields) {
@@ -122,8 +180,11 @@ function getDefaultValues(fields) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  defaultErrorMessages,
+  get,
   getDefaultValues,
   normalizeFieldValue,
+  set,
   validateField,
   validateFieldByName,
   validateForm