@axenstudio/axen-form 0.1.1

package/dist/adapters/yupAdapter.cjs

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function yupAdapter(yup) {
+  return {
+    buildSchema(fields) {
+      const shape = {};
+      for (const field of fields) {
+        if (field.validation) {
+          shape[field.name] = field.validation;
+        } else if (field.required) {
+          const msg = field.requiredMessage ?? `${field.label ?? field.name} is required`;
+          switch (field.type) {
+            case "checkbox":
+            case "switch":
+              shape[field.name] = yup.boolean().oneOf([true], msg).required(msg);
+              break;
+            case "number":
+            case "currency":
+            case "slider":
+              shape[field.name] = yup.number().required(msg).typeError(msg);
+              break;
+            case "autocomplete-multi":
+              shape[field.name] = yup.array().min(1, msg).required(msg);
+              break;
+            default:
+              shape[field.name] = yup.string().required(msg);
+          }
+        }
+      }
+      return yup.object(shape);
+    },
+    async validate(schema, values) {
+      const yupSchema = schema;
+      try {
+        await yupSchema.validate(values, { abortEarly: false });
+        return {};
+      } catch (err) {
+        const validationError = err;
+        const errors = {};
+        if (validationError.inner) {
+          for (const e of validationError.inner) {
+            if (e.path && !errors[e.path]) {
+              errors[e.path] = e.message;
+            }
+          }
+        }
+        return errors;
+      }
+    },
+    async validateField(schema, name, value) {
+      const yupSchema = schema;
+      try {
+        await yupSchema.validateAt(name, { [name]: value });
+        return void 0;
+      } catch (err) {
+        return err.message;
+      }
+    }
+  };
+}
+exports.yupAdapter = yupAdapter;

package/dist/adapters/yupAdapter.d.ts

@@ -0,0 +1,21 @@
+import { ValidationAdapter } from '../types';
+/**
+ * Yup validation adapter.
+ * Uses yup's ObjectSchema for form-level and field-level validation.
+ *
+ * Usage:
+ *   import * as yup from 'yup';
+ *   import { yupAdapter } from '@axenstudio/axen-form/yupAdapter';
+ *
+ *   const adapter = yupAdapter(yup);
+ */
+interface YupLike {
+    boolean(): any;
+    number(): any;
+    string(): any;
+    array(): any;
+    object(shape: Record<string, any>): any;
+}
+export declare function yupAdapter(yup: YupLike): ValidationAdapter;
+export {};
+//# sourceMappingURL=yupAdapter.d.ts.map

package/dist/adapters/yupAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"yupAdapter.d.ts","sourceRoot":"","sources":["../../src/adapters/yupAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE/D;;;;;;;;;GASG;AAGH,UAAU,OAAO;IACf,OAAO,IAAI,GAAG,CAAC;IACf,MAAM,IAAI,GAAG,CAAC;IACd,MAAM,IAAI,GAAG,CAAC;IACd,KAAK,IAAI,GAAG,CAAC;IACb,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,CAAC;CACzC;AAOD,wBAAgB,UAAU,CAAC,GAAG,EAAE,OAAO,GAAG,iBAAiB,CA6D1D"}

package/dist/adapters/yupAdapter.js

@@ -0,0 +1,61 @@
+function yupAdapter(yup) {
+  return {
+    buildSchema(fields) {
+      const shape = {};
+      for (const field of fields) {
+        if (field.validation) {
+          shape[field.name] = field.validation;
+        } else if (field.required) {
+          const msg = field.requiredMessage ?? `${field.label ?? field.name} is required`;
+          switch (field.type) {
+            case "checkbox":
+            case "switch":
+              shape[field.name] = yup.boolean().oneOf([true], msg).required(msg);
+              break;
+            case "number":
+            case "currency":
+            case "slider":
+              shape[field.name] = yup.number().required(msg).typeError(msg);
+              break;
+            case "autocomplete-multi":
+              shape[field.name] = yup.array().min(1, msg).required(msg);
+              break;
+            default:
+              shape[field.name] = yup.string().required(msg);
+          }
+        }
+      }
+      return yup.object(shape);
+    },
+    async validate(schema, values) {
+      const yupSchema = schema;
+      try {
+        await yupSchema.validate(values, { abortEarly: false });
+        return {};
+      } catch (err) {
+        const validationError = err;
+        const errors = {};
+        if (validationError.inner) {
+          for (const e of validationError.inner) {
+            if (e.path && !errors[e.path]) {
+              errors[e.path] = e.message;
+            }
+          }
+        }
+        return errors;
+      }
+    },
+    async validateField(schema, name, value) {
+      const yupSchema = schema;
+      try {
+        await yupSchema.validateAt(name, { [name]: value });
+        return void 0;
+      } catch (err) {
+        return err.message;
+      }
+    }
+  };
+}
+export {
+  yupAdapter
+};

package/dist/adapters/zodAdapter.cjs

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function zodAdapter(z) {
+  return {
+    buildSchema(fields) {
+      const shape = {};
+      for (const field of fields) {
+        if (field.validation) {
+          shape[field.name] = field.validation;
+        } else if (field.required) {
+          const msg = field.requiredMessage ?? `${field.label ?? field.name} is required`;
+          switch (field.type) {
+            case "checkbox":
+            case "switch":
+              shape[field.name] = z.literal(true, { errorMap: () => ({ message: msg }) });
+              break;
+            case "number":
+            case "currency":
+            case "slider":
+              shape[field.name] = z.number({ required_error: msg, invalid_type_error: msg });
+              break;
+            case "autocomplete-multi":
+              shape[field.name] = z.array(z.unknown()).min(1, msg);
+              break;
+            default:
+              shape[field.name] = z.string({ required_error: msg }).min(1, msg);
+          }
+        }
+      }
+      return z.object(shape);
+    },
+    async validate(schema, values) {
+      var _a;
+      const zodSchema = schema;
+      const result = zodSchema.safeParse(values);
+      if (result.success) {
+        return {};
+      }
+      const errors = {};
+      for (const issue of ((_a = result.error) == null ? void 0 : _a.issues) ?? []) {
+        const path = issue.path.join(".");
+        if (path && !errors[path]) {
+          errors[path] = issue.message;
+        }
+      }
+      return errors;
+    },
+    async validateField(schema, name, value) {
+      var _a, _b;
+      const zodSchema = schema;
+      const fieldSchema = zodSchema.shape[name];
+      if (!fieldSchema) return void 0;
+      const result = fieldSchema.safeParse(value);
+      if (result.success) return void 0;
+      return (_b = (_a = result.error) == null ? void 0 : _a.issues[0]) == null ? void 0 : _b.message;
+    }
+  };
+}
+exports.zodAdapter = zodAdapter;

package/dist/adapters/zodAdapter.d.ts

@@ -0,0 +1,22 @@
+import { ValidationAdapter } from '../types';
+/**
+ * Zod validation adapter.
+ * Uses Zod's schema for form-level and field-level validation.
+ *
+ * Usage:
+ *   import { z } from 'zod';
+ *   import { zodAdapter } from '@axenstudio/axen-form/zodAdapter';
+ *
+ *   const adapter = zodAdapter(z);
+ */
+interface ZodLike {
+    literal(value: any, params?: any): any;
+    number(params?: any): any;
+    string(params?: any): any;
+    array(schema: any): any;
+    unknown(): any;
+    object(shape: Record<string, any>): any;
+}
+export declare function zodAdapter(z: ZodLike): ValidationAdapter;
+export {};
+//# sourceMappingURL=zodAdapter.d.ts.map

package/dist/adapters/zodAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zodAdapter.d.ts","sourceRoot":"","sources":["../../src/adapters/zodAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE/D;;;;;;;;;GASG;AAGH,UAAU,OAAO;IACf,OAAO,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,GAAG,GAAG,GAAG,CAAC;IACvC,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,GAAG,GAAG,CAAC;IAC1B,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,GAAG,GAAG,CAAC;IAC1B,KAAK,CAAC,MAAM,EAAE,GAAG,GAAG,GAAG,CAAC;IACxB,OAAO,IAAI,GAAG,CAAC;IACf,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,GAAG,CAAC;CACzC;AAOD,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,GAAG,iBAAiB,CA4DxD"}

package/dist/adapters/zodAdapter.js

@@ -0,0 +1,59 @@
+function zodAdapter(z) {
+  return {
+    buildSchema(fields) {
+      const shape = {};
+      for (const field of fields) {
+        if (field.validation) {
+          shape[field.name] = field.validation;
+        } else if (field.required) {
+          const msg = field.requiredMessage ?? `${field.label ?? field.name} is required`;
+          switch (field.type) {
+            case "checkbox":
+            case "switch":
+              shape[field.name] = z.literal(true, { errorMap: () => ({ message: msg }) });
+              break;
+            case "number":
+            case "currency":
+            case "slider":
+              shape[field.name] = z.number({ required_error: msg, invalid_type_error: msg });
+              break;
+            case "autocomplete-multi":
+              shape[field.name] = z.array(z.unknown()).min(1, msg);
+              break;
+            default:
+              shape[field.name] = z.string({ required_error: msg }).min(1, msg);
+          }
+        }
+      }
+      return z.object(shape);
+    },
+    async validate(schema, values) {
+      var _a;
+      const zodSchema = schema;
+      const result = zodSchema.safeParse(values);
+      if (result.success) {
+        return {};
+      }
+      const errors = {};
+      for (const issue of ((_a = result.error) == null ? void 0 : _a.issues) ?? []) {
+        const path = issue.path.join(".");
+        if (path && !errors[path]) {
+          errors[path] = issue.message;
+        }
+      }
+      return errors;
+    },
+    async validateField(schema, name, value) {
+      var _a, _b;
+      const zodSchema = schema;
+      const fieldSchema = zodSchema.shape[name];
+      if (!fieldSchema) return void 0;
+      const result = fieldSchema.safeParse(value);
+      if (result.success) return void 0;
+      return (_b = (_a = result.error) == null ? void 0 : _a.issues[0]) == null ? void 0 : _b.message;
+    }
+  };
+}
+export {
+  zodAdapter
+};

package/dist/core/dateUtils.cjs

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function formatDateLocale(isoDate, locale) {
+  if (!isoDate) return "";
+  const date = /* @__PURE__ */ new Date(isoDate + "T00:00:00");
+  if (Number.isNaN(date.getTime())) return isoDate;
+  return date.toLocaleDateString(locale ?? navigator.language, {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  });
+}
+function formatTimeLocale(isoTime, locale, ampm) {
+  if (!isoTime) return "";
+  const [hours, minutes] = isoTime.split(":").map(Number);
+  if (Number.isNaN(hours) || Number.isNaN(minutes)) return isoTime;
+  const date = new Date(2e3, 0, 1, hours, minutes);
+  if (Number.isNaN(date.getTime())) return isoTime;
+  return date.toLocaleTimeString(locale ?? navigator.language, {
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: ampm
+  });
+}
+function formatDateTimeLocale(isoDateTime, locale, ampm) {
+  if (!isoDateTime) return "";
+  const date = new Date(isoDateTime);
+  if (Number.isNaN(date.getTime())) return isoDateTime;
+  return date.toLocaleString(locale ?? navigator.language, {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: ampm
+  });
+}
+function toISODateString(date) {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+function toISODateTimeLocalString(date) {
+  const y = date.getFullYear();
+  const mo = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  const h = String(date.getHours()).padStart(2, "0");
+  const mi = String(date.getMinutes()).padStart(2, "0");
+  return `${y}-${mo}-${d}T${h}:${mi}`;
+}
+function toISOTimeString(date) {
+  const h = String(date.getHours()).padStart(2, "0");
+  const m = String(date.getMinutes()).padStart(2, "0");
+  return `${h}:${m}`;
+}
+function getDefaultLocale() {
+  if (typeof navigator !== "undefined" && navigator.language) {
+    return navigator.language;
+  }
+  return "en-US";
+}
+exports.formatDateLocale = formatDateLocale;
+exports.formatDateTimeLocale = formatDateTimeLocale;
+exports.formatTimeLocale = formatTimeLocale;
+exports.getDefaultLocale = getDefaultLocale;
+exports.toISODateString = toISODateString;
+exports.toISODateTimeLocalString = toISODateTimeLocalString;
+exports.toISOTimeString = toISOTimeString;

package/dist/core/dateUtils.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Date/Time locale-aware utilities.
+ *
+ * Display: locale-aware (user sees dates/times in their locale format)
+ * Storage/Payload: always ISO standard (YYYY-MM-DD, HH:MM, YYYY-MM-DDTHH:MM)
+ */
+/** Format an ISO date string to locale display */
+export declare function formatDateLocale(isoDate: string, locale?: string): string;
+/** Format an ISO time string (HH:MM or HH:MM:SS) to locale display */
+export declare function formatTimeLocale(isoTime: string, locale?: string, ampm?: boolean): string;
+/** Format an ISO datetime-local string to locale display */
+export declare function formatDateTimeLocale(isoDateTime: string, locale?: string, ampm?: boolean): string;
+/** Parse a locale-formatted date back to ISO (YYYY-MM-DD) */
+export declare function parseDateToISO(displayValue: string, _locale?: string): string;
+/** Parse a locale-formatted datetime back to ISO datetime-local */
+export declare function parseDateTimeToISO(displayValue: string): string;
+/** Convert Date to YYYY-MM-DD */
+export declare function toISODateString(date: Date): string;
+/** Convert Date to YYYY-MM-DDTHH:MM (datetime-local format) */
+export declare function toISODateTimeLocalString(date: Date): string;
+/** Convert Date to HH:MM */
+export declare function toISOTimeString(date: Date): string;
+/**
+ * Get the user's default locale.
+ * Falls back to 'en-US' in non-browser environments (SSR/tests).
+ */
+export declare function getDefaultLocale(): string;
+//# sourceMappingURL=dateUtils.d.ts.map

package/dist/core/dateUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dateUtils.d.ts","sourceRoot":"","sources":["../../src/core/dateUtils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,kDAAkD;AAClD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CASzE;AAED,sEAAsE;AACtE,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,CAYzF;AAED,4DAA4D;AAC5D,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,CAYjG;AAED,6DAA6D;AAC7D,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAQ7E;AAED,mEAAmE;AACnE,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAO/D;AAED,iCAAiC;AACjC,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAKlD;AAED,+DAA+D;AAC/D,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAO3D;AAED,4BAA4B;AAC5B,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAIlD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAKzC"}

package/dist/core/dateUtils.js

@@ -0,0 +1,69 @@
+function formatDateLocale(isoDate, locale) {
+  if (!isoDate) return "";
+  const date = /* @__PURE__ */ new Date(isoDate + "T00:00:00");
+  if (Number.isNaN(date.getTime())) return isoDate;
+  return date.toLocaleDateString(locale ?? navigator.language, {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  });
+}
+function formatTimeLocale(isoTime, locale, ampm) {
+  if (!isoTime) return "";
+  const [hours, minutes] = isoTime.split(":").map(Number);
+  if (Number.isNaN(hours) || Number.isNaN(minutes)) return isoTime;
+  const date = new Date(2e3, 0, 1, hours, minutes);
+  if (Number.isNaN(date.getTime())) return isoTime;
+  return date.toLocaleTimeString(locale ?? navigator.language, {
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: ampm
+  });
+}
+function formatDateTimeLocale(isoDateTime, locale, ampm) {
+  if (!isoDateTime) return "";
+  const date = new Date(isoDateTime);
+  if (Number.isNaN(date.getTime())) return isoDateTime;
+  return date.toLocaleString(locale ?? navigator.language, {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: ampm
+  });
+}
+function toISODateString(date) {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+function toISODateTimeLocalString(date) {
+  const y = date.getFullYear();
+  const mo = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  const h = String(date.getHours()).padStart(2, "0");
+  const mi = String(date.getMinutes()).padStart(2, "0");
+  return `${y}-${mo}-${d}T${h}:${mi}`;
+}
+function toISOTimeString(date) {
+  const h = String(date.getHours()).padStart(2, "0");
+  const m = String(date.getMinutes()).padStart(2, "0");
+  return `${h}:${m}`;
+}
+function getDefaultLocale() {
+  if (typeof navigator !== "undefined" && navigator.language) {
+    return navigator.language;
+  }
+  return "en-US";
+}
+export {
+  formatDateLocale,
+  formatDateTimeLocale,
+  formatTimeLocale,
+  getDefaultLocale,
+  toISODateString,
+  toISODateTimeLocalString,
+  toISOTimeString
+};

package/dist/core/formStore.cjs

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const pathUtils = require("./pathUtils.cjs");
+function createFormStore(options) {
+  const {
+    initialValues,
+    validationAdapter,
+    validateOnChange = true,
+    validateOnBlur = true
+  } = options;
+  let state = {
+    values: structuredClone(initialValues),
+    errors: {},
+    touched: {},
+    dirty: false,
+    isSubmitting: false,
+    submitCount: 0,
+    initialValues: structuredClone(initialValues)
+  };
+  const subscribers = /* @__PURE__ */ new Set();
+  const fieldSubscribers = /* @__PURE__ */ new Map();
+  let validationSchema = options.validationSchema;
+  if (validationAdapter && options.fields && !validationSchema) {
+    validationSchema = validationAdapter.buildSchema(options.fields);
+  }
+  function getState() {
+    return state;
+  }
+  function subscribe(listener) {
+    subscribers.add(listener);
+    return () => subscribers.delete(listener);
+  }
+  function subscribeField(name, listener) {
+    var _a;
+    if (!fieldSubscribers.has(name)) {
+      fieldSubscribers.set(name, /* @__PURE__ */ new Set());
+    }
+    (_a = fieldSubscribers.get(name)) == null ? void 0 : _a.add(listener);
+    return () => {
+      var _a2;
+      return (_a2 = fieldSubscribers.get(name)) == null ? void 0 : _a2.delete(listener);
+    };
+  }
+  function notify() {
+    subscribers.forEach((fn) => fn());
+  }
+  function notifyField(name) {
+    var _a;
+    (_a = fieldSubscribers.get(name)) == null ? void 0 : _a.forEach((fn) => fn());
+  }
+  function setFieldValue(name, value) {
+    state = {
+      ...state,
+      values: pathUtils.set(state.values, name, value),
+      dirty: true
+    };
+    notifyField(name);
+    notify();
+    if (validateOnChange && validationAdapter && validationSchema) {
+      runFieldValidation(name);
+    }
+  }
+  function setFieldTouched(name, touched = true) {
+    state = {
+      ...state,
+      touched: { ...state.touched, [name]: touched }
+    };
+    notifyField(name);
+    notify();
+    if (validateOnBlur && touched && validationAdapter && validationSchema) {
+      runFieldValidation(name);
+    }
+  }
+  function setFieldError(name, error) {
+    const next = { ...state.errors };
+    if (error) {
+      next[name] = error;
+    } else {
+      delete next[name];
+    }
+    state = { ...state, errors: next };
+    notifyField(name);
+    notify();
+  }
+  function setValues(values) {
+    state = { ...state, values, dirty: true };
+    notify();
+    subscribers.forEach((fn) => fn());
+  }
+  function setErrors(errors) {
+    state = { ...state, errors };
+    notify();
+  }
+  function resetForm(nextValues) {
+    const newValues = nextValues ? { ...state.initialValues, ...nextValues } : structuredClone(state.initialValues);
+    state = {
+      values: newValues,
+      errors: {},
+      touched: {},
+      dirty: false,
+      isSubmitting: false,
+      submitCount: state.submitCount,
+      initialValues: state.initialValues
+    };
+    notify();
+  }
+  async function validateForm() {
+    if (!validationAdapter || !validationSchema) return {};
+    const errors = await validationAdapter.validate(validationSchema, state.values);
+    state = { ...state, errors };
+    notify();
+    return errors;
+  }
+  async function validateField(name) {
+    if (!(validationAdapter == null ? void 0 : validationAdapter.validateField) || !validationSchema) return void 0;
+    const fieldValue = pathUtils.get(state.values, name);
+    const error = await validationAdapter.validateField(validationSchema, name, fieldValue);
+    setFieldError(name, error);
+    return error;
+  }
+  async function runFieldValidation(name) {
+    if (validationAdapter == null ? void 0 : validationAdapter.validateField) {
+      await validateField(name);
+    } else {
+      await validateForm();
+    }
+  }
+  async function submitForm(onSubmit) {
+    state = { ...state, isSubmitting: true, submitCount: state.submitCount + 1 };
+    notify();
+    const allTouched = {};
+    if (options.fields) {
+      for (const field of options.fields) {
+        allTouched[field.name] = true;
+      }
+    }
+    state = { ...state, touched: { ...state.touched, ...allTouched } };
+    const errors = await validateForm();
+    if (Object.keys(errors).length > 0) {
+      state = { ...state, isSubmitting: false };
+      notify();
+      return;
+    }
+    const handler = onSubmit ?? options.onSubmit;
+    if (handler) {
+      try {
+        await handler(state.values);
+      } finally {
+        state = { ...state, isSubmitting: false };
+        notify();
+      }
+    } else {
+      state = { ...state, isSubmitting: false };
+      notify();
+    }
+  }
+  function getFieldValue(name) {
+    return pathUtils.get(state.values, name);
+  }
+  function getFieldError(name) {
+    return state.errors[name];
+  }
+  function getFieldTouched(name) {
+    return state.touched[name] ?? false;
+  }
+  return {
+    getState,
+    subscribe,
+    subscribeField,
+    setFieldValue,
+    setFieldTouched,
+    setFieldError,
+    setValues,
+    setErrors,
+    resetForm,
+    validateForm,
+    validateField,
+    submitForm,
+    getFieldValue,
+    getFieldError,
+    getFieldTouched
+  };
+}
+exports.createFormStore = createFormStore;

package/dist/core/formStore.d.ts

@@ -0,0 +1,39 @@
+import { FieldConfig, ValidationAdapter } from '../types';
+export interface FormState<TValues extends Record<string, unknown> = Record<string, unknown>> {
+    values: TValues;
+    errors: Record<string, string>;
+    touched: Record<string, boolean>;
+    dirty: boolean;
+    isSubmitting: boolean;
+    submitCount: number;
+    initialValues: TValues;
+}
+export type Subscriber = () => void;
+export interface FormStoreOptions<TValues extends Record<string, unknown>> {
+    initialValues: TValues;
+    validationAdapter?: ValidationAdapter;
+    validationSchema?: unknown;
+    fields?: FieldConfig[];
+    validateOnChange?: boolean;
+    validateOnBlur?: boolean;
+    onSubmit?: (values: TValues) => void | Promise<void>;
+}
+export declare function createFormStore<TValues extends Record<string, unknown>>(options: FormStoreOptions<TValues>): {
+    getState: () => FormState<TValues>;
+    subscribe: (listener: Subscriber) => () => void;
+    subscribeField: (name: string, listener: Subscriber) => () => void;
+    setFieldValue: (name: string, value: unknown) => void;
+    setFieldTouched: (name: string, touched?: boolean) => void;
+    setFieldError: (name: string, error: string | undefined) => void;
+    setValues: (values: TValues) => void;
+    setErrors: (errors: Record<string, string>) => void;
+    resetForm: (nextValues?: Partial<TValues>) => void;
+    validateForm: () => Promise<Record<string, string>>;
+    validateField: (name: string) => Promise<string | undefined>;
+    submitForm: (onSubmit?: (values: TValues) => void | Promise<void>) => Promise<void>;
+    getFieldValue: (name: string) => unknown;
+    getFieldError: (name: string) => string | undefined;
+    getFieldTouched: (name: string) => boolean;
+};
+export type FormStore<TValues extends Record<string, unknown> = Record<string, unknown>> = ReturnType<typeof createFormStore<TValues>>;
+//# sourceMappingURL=formStore.d.ts.map