pdyform 2.1.0 → 2.2.1

package/packages/core/dist/formState.cjs

@@ -20,13 +20,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/formState.ts
 var formState_exports = {};
 __export(formState_exports, {
-  applyFieldBlur: () => applyFieldBlur,
-  applyFieldChange: () => applyFieldChange,
-  createFormRuntimeState: () => createFormRuntimeState,
-  runSubmitValidation: () => runSubmitValidation,
-  setSubmitting: () => setSubmitting
+  createFormStore: () => createFormStore
 });
 module.exports = __toCommonJS(formState_exports);
+var import_vanilla = require("zustand/vanilla");
 
 // src/utils.ts
 function parseNumberish(value) {
@@ -35,85 +32,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) {
@@ -124,64 +176,74 @@ function getDefaultValues(fields) {
 }
 
 // src/formState.ts
-function createFormRuntimeState(fields) {
-  return {
+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,
-  runSubmitValidation,
-  setSubmitting
+  createFormStore
 });

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

@@ -1,17 +1,21 @@
-import { FormField } from './types.cjs';
+import * as zustand_vanilla from 'zustand/vanilla';
+import { FormField, FormResolver, ErrorMessageTemplates } from './types.cjs';
 
 interface FormRuntimeState {
     values: Record<string, any>;
     errors: Record<string, string>;
+    validatingFields: string[];
     isSubmitting: boolean;
 }
-declare function createFormRuntimeState(fields: FormField[]): FormRuntimeState;
-declare function setSubmitting(state: FormRuntimeState, isSubmitting: boolean): FormRuntimeState;
-declare function applyFieldChange(fields: FormField[], state: FormRuntimeState, name: string, rawValue: unknown): FormRuntimeState;
-declare function applyFieldBlur(fields: FormField[], state: FormRuntimeState, name: string): FormRuntimeState;
-declare function runSubmitValidation(fields: FormField[], state: FormRuntimeState): {
-    state: FormRuntimeState;
-    hasError: boolean;
-};
+interface FormStore extends FormRuntimeState {
+    setFieldValue: (name: string, rawValue: unknown) => Promise<void>;
+    setFieldBlur: (name: string) => Promise<void>;
+    setSubmitting: (isSubmitting: boolean) => void;
+    runSubmitValidation: () => Promise<{
+        state: FormRuntimeState;
+        hasError: boolean;
+    }>;
+}
+declare function createFormStore(fields: FormField[], resolver?: FormResolver, errorMessages?: ErrorMessageTemplates): zustand_vanilla.StoreApi<FormStore>;
 
-export { type FormRuntimeState, applyFieldBlur, applyFieldChange, createFormRuntimeState, runSubmitValidation, setSubmitting };
+export { type FormRuntimeState, type FormStore, createFormStore };

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

@@ -1,17 +1,21 @@
-import { FormField } from './types.js';
+import * as zustand_vanilla from 'zustand/vanilla';
+import { FormField, FormResolver, ErrorMessageTemplates } from './types.js';
 
 interface FormRuntimeState {
     values: Record<string, any>;
     errors: Record<string, string>;
+    validatingFields: string[];
     isSubmitting: boolean;
 }
-declare function createFormRuntimeState(fields: FormField[]): FormRuntimeState;
-declare function setSubmitting(state: FormRuntimeState, isSubmitting: boolean): FormRuntimeState;
-declare function applyFieldChange(fields: FormField[], state: FormRuntimeState, name: string, rawValue: unknown): FormRuntimeState;
-declare function applyFieldBlur(fields: FormField[], state: FormRuntimeState, name: string): FormRuntimeState;
-declare function runSubmitValidation(fields: FormField[], state: FormRuntimeState): {
-    state: FormRuntimeState;
-    hasError: boolean;
-};
+interface FormStore extends FormRuntimeState {
+    setFieldValue: (name: string, rawValue: unknown) => Promise<void>;
+    setFieldBlur: (name: string) => Promise<void>;
+    setSubmitting: (isSubmitting: boolean) => void;
+    runSubmitValidation: () => Promise<{
+        state: FormRuntimeState;
+        hasError: boolean;
+    }>;
+}
+declare function createFormStore(fields: FormField[], resolver?: FormResolver, errorMessages?: ErrorMessageTemplates): zustand_vanilla.StoreApi<FormStore>;
 
-export { type FormRuntimeState, applyFieldBlur, applyFieldChange, createFormRuntimeState, runSubmitValidation, setSubmitting };
+export { type FormRuntimeState, type FormStore, createFormStore };

package/packages/core/dist/formState.js

@@ -1,15 +1,7 @@
 import {
-  applyFieldBlur,
-  applyFieldChange,
-  createFormRuntimeState,
-  runSubmitValidation,
-  setSubmitting
-} from "./chunk-TP3IHKWV.js";
-import "./chunk-WEDHXOHH.js";
+  createFormStore
+} from "./chunk-J6ESJZ4U.js";
+import "./chunk-B7OMM2UC.js";
 export {
-  applyFieldBlur,
-  applyFieldChange,
-  createFormRuntimeState,
-  runSubmitValidation,
-  setSubmitting
+  createFormStore
 };