@thalesfp/snapstate 0.1.0

package/dist/form/index.cjs

@@ -0,0 +1,1177 @@
+"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/form/index.ts
+var form_exports = {};
+__export(form_exports, {
+  SnapFormStore: () => SnapFormStore,
+  asyncStatus: () => asyncStatus,
+  getBaseSchemaType: () => getBaseSchemaType,
+  getObjectSchema: () => getObjectSchema,
+  setDefaultHeaders: () => setDefaultHeaders,
+  setHttpClient: () => setHttpClient
+});
+module.exports = __toCommonJS(form_exports);
+
+// src/form/form.ts
+var import_zod = require("zod");
+
+// src/react/store.ts
+var import_react = require("react");
+
+// src/core/types.ts
+var _statuses = {
+  idle: Object.freeze({ value: "idle", isIdle: true, isLoading: false, isReady: false, isError: false }),
+  loading: Object.freeze({ value: "loading", isIdle: false, isLoading: true, isReady: false, isError: false }),
+  ready: Object.freeze({ value: "ready", isIdle: false, isLoading: false, isReady: true, isError: false }),
+  error: Object.freeze({ value: "error", isIdle: false, isLoading: false, isReady: false, isError: true })
+};
+function asyncStatus(value) {
+  return _statuses[value];
+}
+
+// src/core/trie.ts
+function invokeAll(listeners) {
+  let firstError;
+  for (const l of listeners) {
+    try {
+      l();
+    } catch (e) {
+      firstError ??= e;
+    }
+  }
+  if (firstError !== void 0) {
+    throw firstError;
+  }
+}
+function createNode() {
+  return { listeners: /* @__PURE__ */ new Set(), children: /* @__PURE__ */ new Map() };
+}
+function parsePath(path) {
+  if (path === "") {
+    return [];
+  }
+  return path.split(".");
+}
+var SubscriptionTrie = class {
+  root = createNode();
+  globalListeners = /* @__PURE__ */ new Set();
+  /** Subscribe to a specific path. Returns unsubscribe function. */
+  add(path, listener) {
+    const segments = parsePath(path);
+    const parents = [];
+    let node = this.root;
+    for (const seg of segments) {
+      if (!node.children.has(seg)) {
+        node.children.set(seg, createNode());
+      }
+      parents.push({ parent: node, segment: seg });
+      node = node.children.get(seg);
+    }
+    node.listeners.add(listener);
+    return () => {
+      node.listeners.delete(listener);
+      for (let i = parents.length - 1; i >= 0; i--) {
+        const { parent, segment } = parents[i];
+        const child = parent.children.get(segment);
+        if (child.listeners.size === 0 && child.children.size === 0) {
+          parent.children.delete(segment);
+        } else {
+          break;
+        }
+      }
+    };
+  }
+  /** Subscribe to all changes (no path filter). */
+  addGlobal(listener) {
+    this.globalListeners.add(listener);
+    return () => {
+      this.globalListeners.delete(listener);
+    };
+  }
+  /** Notify listeners for exact path, all ancestors, and all descendants. */
+  notify(path) {
+    const segments = parsePath(path);
+    const collected = /* @__PURE__ */ new Set();
+    for (const l of this.globalListeners) collected.add(l);
+    let node = this.root;
+    for (const l of node.listeners) collected.add(l);
+    let matched = true;
+    for (const seg of segments) {
+      const wildcard = node.children.get("*");
+      if (wildcard) {
+        for (const l of wildcard.listeners) collected.add(l);
+        this.collectDescendants(wildcard, collected);
+      }
+      const child = node.children.get(seg);
+      if (!child) {
+        matched = false;
+        break;
+      }
+      node = child;
+      for (const l of node.listeners) collected.add(l);
+    }
+    if (matched) {
+      this.collectDescendants(node, collected);
+    }
+    invokeAll(collected);
+  }
+  /** Notify all listeners in the trie. */
+  notifyAll() {
+    const collected = /* @__PURE__ */ new Set();
+    for (const l of this.globalListeners) collected.add(l);
+    this.collectDescendants(this.root, collected);
+    for (const l of this.root.listeners) collected.add(l);
+    invokeAll(collected);
+  }
+  collectDescendants(node, out) {
+    for (const child of node.children.values()) {
+      for (const l of child.listeners) out.add(l);
+      this.collectDescendants(child, out);
+    }
+  }
+  clear() {
+    this.root = createNode();
+    this.globalListeners.clear();
+  }
+};
+
+// src/core/structural.ts
+function applyUpdate(state, path, value) {
+  const segments = path.split(".");
+  return updateAtPath(state, segments, 0, value);
+}
+function updateAtPath(current, segments, index, value) {
+  if (index === segments.length) {
+    if (typeof value === "function") {
+      return value(current);
+    }
+    return value;
+  }
+  const key = segments[index];
+  if (Array.isArray(current)) {
+    const i = Number(key);
+    const next2 = updateAtPath(current[i], segments, index + 1, value);
+    if (Object.is(next2, current[i])) {
+      return current;
+    }
+    const copy = current.slice();
+    copy[i] = next2;
+    return copy;
+  }
+  if (current !== null && typeof current === "object") {
+    const obj = current;
+    const next2 = updateAtPath(obj[key], segments, index + 1, value);
+    if (Object.is(next2, obj[key])) {
+      return current;
+    }
+    return { ...obj, [key]: next2 };
+  }
+  const next = updateAtPath(void 0, segments, index + 1, value);
+  return { [key]: next };
+}
+function getAtPath(state, path) {
+  if (path === "") {
+    return state;
+  }
+  const segments = path.split(".");
+  let current = state;
+  for (const seg of segments) {
+    if (current === null || current === void 0) {
+      return void 0;
+    }
+    current = current[seg];
+  }
+  return current;
+}
+
+// src/core/computed.ts
+function createComputed(host, deps, fn) {
+  let cachedValue;
+  let dirty = true;
+  const unsubs = [];
+  const markDirty = () => {
+    dirty = true;
+  };
+  for (const dep of deps) {
+    unsubs.push(host.subscribe(dep, markDirty));
+  }
+  try {
+    cachedValue = fn(host.getSnapshot());
+  } catch (e) {
+    for (const unsub of unsubs) unsub();
+    unsubs.length = 0;
+    throw e;
+  }
+  dirty = false;
+  return {
+    get() {
+      if (dirty) {
+        cachedValue = fn(host.getSnapshot());
+        dirty = false;
+      }
+      return cachedValue;
+    },
+    destroy() {
+      for (const unsub of unsubs) unsub();
+      unsubs.length = 0;
+    }
+  };
+}
+
+// src/core/store.ts
+function createStore(initialState, options = {}) {
+  const { autoBatch = true } = options;
+  let state = initialState;
+  const trie = new SubscriptionTrie();
+  let batchDepth = 0;
+  let pendingPaths = /* @__PURE__ */ new Set();
+  let microtaskScheduled = false;
+  function flushNotifications() {
+    const paths = pendingPaths;
+    pendingPaths = /* @__PURE__ */ new Set();
+    microtaskScheduled = false;
+    if (paths.size === 0) {
+      return;
+    }
+    const sorted = [...paths].sort();
+    const deduped = [];
+    for (const p of sorted) {
+      const last = deduped[deduped.length - 1];
+      if (last !== void 0 && p.startsWith(last + ".")) {
+        continue;
+      }
+      deduped.push(p);
+    }
+    for (const path of deduped) {
+      trie.notify(path);
+    }
+  }
+  function scheduleFlush() {
+    if (batchDepth > 0) {
+      return;
+    }
+    if (autoBatch && !microtaskScheduled) {
+      microtaskScheduled = true;
+      queueMicrotask(flushNotifications);
+    } else if (!autoBatch) {
+      flushNotifications();
+    }
+  }
+  function get(path) {
+    if (path === void 0 || path === "") {
+      return state;
+    }
+    return getAtPath(state, path);
+  }
+  function set(path, value) {
+    if (path === "") {
+      throw new Error("Cannot set with an empty path. Use a specific path to update state.");
+    }
+    const prev = state;
+    state = applyUpdate(state, path, value);
+    if (state !== prev) {
+      pendingPaths.add(path);
+      scheduleFlush();
+    }
+  }
+  function batch(fn) {
+    batchDepth++;
+    try {
+      fn();
+    } finally {
+      batchDepth--;
+      if (batchDepth === 0) {
+        flushNotifications();
+      }
+    }
+  }
+  function subscribe(pathOrCallback, callback) {
+    if (typeof pathOrCallback === "function") {
+      return trie.addGlobal(pathOrCallback);
+    }
+    return trie.add(pathOrCallback, callback);
+  }
+  function getSnapshot() {
+    return state;
+  }
+  function computed(deps, fn) {
+    return createComputed({ getSnapshot, subscribe }, deps, fn);
+  }
+  function notify() {
+    trie.notifyAll();
+  }
+  function destroy() {
+    trie.clear();
+    pendingPaths.clear();
+  }
+  return {
+    get,
+    set,
+    batch,
+    subscribe,
+    getSnapshot,
+    computed,
+    notify,
+    destroy
+  };
+}
+
+// src/core/base.ts
+var IDLE_STATE = { status: asyncStatus("idle"), error: null };
+var defaultHttpClient = {
+  async request(url, init) {
+    const fetchInit = { method: init?.method ?? "GET" };
+    const merged = { ...defaultHeaders, ...init?.headers };
+    if (Object.keys(merged).length) {
+      fetchInit.headers = merged;
+    }
+    if (init?.body !== void 0) {
+      fetchInit.body = JSON.stringify(init.body);
+      fetchInit.headers = { "Content-Type": "application/json", ...merged };
+    }
+    const res = await fetch(url, fetchInit);
+    if (!res.ok) {
+      let message = `HTTP ${res.status}`;
+      try {
+        const text2 = await res.text();
+        if (text2) {
+          const json = JSON.parse(text2);
+          message = json.error ?? json.message ?? message;
+        }
+      } catch {
+      }
+      throw new Error(message);
+    }
+    const text = await res.text();
+    return text ? JSON.parse(text) : void 0;
+  }
+};
+var httpClient = defaultHttpClient;
+var defaultHeaders = {};
+function setHttpClient(client) {
+  httpClient = client;
+}
+function setDefaultHeaders(headers) {
+  defaultHeaders = headers;
+}
+var SnapStore = class {
+  _store;
+  _operations = /* @__PURE__ */ new Map();
+  _generations = /* @__PURE__ */ new Map();
+  state;
+  api;
+  constructor(initialState, options) {
+    this._store = createStore(initialState, options);
+    const store = this._store;
+    const operations = this._operations;
+    const generations = this._generations;
+    const doFetch = async (key, fn) => {
+      const gen = (generations.get(key) ?? 0) + 1;
+      generations.set(key, gen);
+      operations.set(key, { status: asyncStatus("loading"), error: null });
+      store.notify();
+      try {
+        await fn();
+        if (generations.get(key) !== gen) {
+          return;
+        }
+        operations.set(key, { status: asyncStatus("ready"), error: null });
+      } catch (e) {
+        if (generations.get(key) !== gen) {
+          return;
+        }
+        operations.set(key, {
+          status: asyncStatus("error"),
+          error: e instanceof Error ? e.message : "Unknown error"
+        });
+        store.notify();
+        throw e;
+      }
+      store.notify();
+    };
+    const doSend = async (key, method, url, options2) => {
+      await doFetch(key, async () => {
+        try {
+          const data = await httpClient.request(url, {
+            method,
+            body: options2?.body,
+            headers: options2?.headers
+          });
+          options2?.onSuccess?.(data);
+        } catch (e) {
+          options2?.onError?.(e instanceof Error ? e : new Error("Unknown error"));
+          throw e;
+        }
+      });
+    };
+    this.state = {
+      get: ((path) => {
+        if (path === void 0) {
+          return store.get();
+        }
+        return store.get(path);
+      }),
+      set: (path, value) => store.set(path, value),
+      batch: (fn) => store.batch(fn),
+      computed: (deps, fn) => store.computed(deps, fn),
+      append: (path, ...items) => {
+        store.set(path, ((prev) => [...prev, ...items]));
+      },
+      prepend: (path, ...items) => {
+        store.set(path, ((prev) => [...items, ...prev]));
+      },
+      insertAt: (path, index, ...items) => {
+        store.set(path, ((prev) => {
+          const arr = prev;
+          return [...arr.slice(0, index), ...items, ...arr.slice(index)];
+        }));
+      },
+      patch: (path, predicate, updates) => {
+        store.set(path, ((prev) => {
+          const arr = prev;
+          let changed = false;
+          const result = arr.map((item) => {
+            if (item == null) {
+              return item;
+            }
+            if (predicate(item)) {
+              changed = true;
+              return Object.assign(Object.create(Object.getPrototypeOf(item)), item, updates);
+            }
+            return item;
+          });
+          return changed ? result : arr;
+        }));
+      },
+      remove: (path, predicate) => {
+        store.set(path, ((prev) => {
+          const arr = prev;
+          const result = arr.filter((item) => !predicate(item));
+          return result.length === arr.length ? arr : result;
+        }));
+      },
+      removeAt: (path, index) => {
+        store.set(path, ((prev) => {
+          const arr = prev;
+          const i = index < 0 ? arr.length + index : index;
+          if (i < 0 || i >= arr.length) {
+            throw new RangeError(`Index ${index} out of bounds for array of length ${arr.length}`);
+          }
+          return [...arr.slice(0, i), ...arr.slice(i + 1)];
+        }));
+      },
+      at: (path, index) => {
+        return store.get(path).at(index);
+      },
+      filter: (path, predicate) => {
+        return store.get(path).filter(predicate);
+      },
+      find: (path, predicate) => {
+        return store.get(path).find(predicate);
+      },
+      findIndexOf: (path, predicate) => {
+        return store.get(path).findIndex(predicate);
+      },
+      count: (path, predicate) => {
+        return store.get(path).filter(predicate).length;
+      }
+    };
+    this.api = {
+      fetch: doFetch,
+      get: async (key, url, onSuccess) => {
+        await doFetch(key, async () => {
+          const data = await httpClient.request(url);
+          onSuccess?.(data);
+        });
+      },
+      post: (key, url, options2) => doSend(key, "POST", url, options2),
+      put: (key, url, options2) => doSend(key, "PUT", url, options2),
+      patch: (key, url, options2) => doSend(key, "PATCH", url, options2),
+      delete: (key, url, options2) => doSend(key, "DELETE", url, options2)
+    };
+  }
+  subscribe(pathOrCallback, callback) {
+    if (typeof pathOrCallback === "function") {
+      return this._store.subscribe(pathOrCallback);
+    }
+    return this._store.subscribe(pathOrCallback, callback);
+  }
+  /** Return a snapshot of the current state. Compatible with React's `useSyncExternalStore`. */
+  getSnapshot = () => {
+    return this._store.getSnapshot();
+  };
+  /** Get the async status of an operation by key. Returns `idle` if never started. */
+  getStatus(key) {
+    return { ...this._operations.get(key) ?? IDLE_STATE };
+  }
+  /** Tear down subscriptions and cleanup. */
+  destroy() {
+    this._store.destroy();
+  }
+};
+
+// src/react/store.ts
+function shallowEqual(a, b) {
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+  for (const key of keysA) {
+    if (a[key] !== b[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+var ReactSnapStore = class extends SnapStore {
+  constructor(initialState, options) {
+    super(initialState, options);
+  }
+  connect(Component, configOrMapper) {
+    const store = this;
+    if (typeof configOrMapper === "object" && "select" in configOrMapper) {
+      return this._connectWithSelect(Component, configOrMapper.select);
+    }
+    const mapToProps = typeof configOrMapper === "function" ? configOrMapper : configOrMapper.props;
+    const fetchFn = typeof configOrMapper === "function" ? void 0 : configOrMapper.fetch;
+    const loadingComponent = typeof configOrMapper === "function" ? void 0 : configOrMapper.loading;
+    const errorComponent = typeof configOrMapper === "function" ? void 0 : configOrMapper.error;
+    const Connected = (0, import_react.forwardRef)(function Connected2(ownProps, ref) {
+      const cachedRef = (0, import_react.useRef)(null);
+      const revisionRef = (0, import_react.useRef)(0);
+      const subscribe = (0, import_react.useCallback)(
+        (cb) => store.subscribe(() => {
+          revisionRef.current++;
+          cb();
+        }),
+        [store]
+      );
+      const getSnapshot = (0, import_react.useCallback)(() => {
+        const currentRevision = revisionRef.current;
+        if (cachedRef.current && cachedRef.current.revision === currentRevision) {
+          return cachedRef.current.props;
+        }
+        const next = mapToProps(store);
+        if (cachedRef.current && shallowEqual(cachedRef.current.props, next)) {
+          cachedRef.current = { revision: currentRevision, props: cachedRef.current.props };
+          return cachedRef.current.props;
+        }
+        cachedRef.current = { revision: currentRevision, props: next };
+        return next;
+      }, [store]);
+      const mappedProps = (0, import_react.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+      const [asyncState, setAsyncState] = (0, import_react.useState)({ status: asyncStatus("idle"), error: null });
+      const fetchGenRef = (0, import_react.useRef)(0);
+      (0, import_react.useEffect)(() => {
+        if (!fetchFn) {
+          return;
+        }
+        let cancelled = false;
+        const gen = ++fetchGenRef.current;
+        setAsyncState({ status: asyncStatus("loading"), error: null });
+        Promise.resolve().then(() => {
+          if (cancelled) {
+            return;
+          }
+          return fetchFn(store);
+        }).then(() => {
+          if (gen === fetchGenRef.current) {
+            setAsyncState({ status: asyncStatus("ready"), error: null });
+          }
+        }).catch((e) => {
+          if (gen === fetchGenRef.current) {
+            setAsyncState({
+              status: asyncStatus("error"),
+              error: e instanceof Error ? e.message : "Unknown error"
+            });
+          }
+        });
+        return () => {
+          cancelled = true;
+        };
+      }, []);
+      if (fetchFn) {
+        if (loadingComponent && (asyncState.status.isIdle || asyncState.status.isLoading)) {
+          return (0, import_react.createElement)(loadingComponent);
+        }
+        if (errorComponent && asyncState.status.isError) {
+          return (0, import_react.createElement)(errorComponent, { error: asyncState.error });
+        }
+      }
+      return (0, import_react.createElement)(Component, {
+        ...ownProps,
+        ...mappedProps,
+        ...fetchFn ? asyncState : {},
+        ref
+      });
+    });
+    Connected.displayName = `Connect(${Component.displayName || Component.name || "Component"})`;
+    return Connected;
+  }
+  _connectWithSelect(Component, selectFn) {
+    const store = this;
+    const resolvePathValue = (path) => {
+      const segments = path.split(".");
+      let val = store.getSnapshot();
+      for (const seg of segments) {
+        if (val == null) {
+          return void 0;
+        }
+        val = val[seg];
+      }
+      return val;
+    };
+    const trackedPaths = [];
+    const trackingPick = ((path) => {
+      trackedPaths.push(path);
+      return resolvePathValue(path);
+    });
+    selectFn(trackingPick);
+    const paths = [...trackedPaths];
+    const readPick = ((path) => {
+      return resolvePathValue(path);
+    });
+    const Connected = (0, import_react.forwardRef)(function Connected2(ownProps, ref) {
+      const cachedRef = (0, import_react.useRef)(null);
+      const revisionRef = (0, import_react.useRef)(0);
+      const subscribe = (0, import_react.useCallback)(
+        (cb) => {
+          const unsubs = paths.map(
+            (p) => store.subscribe(p, () => {
+              revisionRef.current++;
+              cb();
+            })
+          );
+          return () => unsubs.forEach((u) => u());
+        },
+        [store]
+      );
+      const getSnapshot = (0, import_react.useCallback)(() => {
+        const currentRevision = revisionRef.current;
+        if (cachedRef.current && cachedRef.current.revision === currentRevision) {
+          return cachedRef.current.props;
+        }
+        const next = selectFn(readPick);
+        if (cachedRef.current && shallowEqual(cachedRef.current.props, next)) {
+          cachedRef.current = { revision: currentRevision, props: cachedRef.current.props };
+          return cachedRef.current.props;
+        }
+        cachedRef.current = { revision: currentRevision, props: next };
+        return next;
+      }, [store]);
+      const mappedProps = (0, import_react.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+      return (0, import_react.createElement)(Component, {
+        ...ownProps,
+        ...mappedProps,
+        ref
+      });
+    });
+    Connected.displayName = `Connect(${Component.displayName || Component.name || "Component"})`;
+    return Connected;
+  }
+};
+
+// src/form/form.ts
+function getObjectSchema(schema) {
+  if (schema instanceof import_zod.z.ZodObject) return schema;
+  if (schema instanceof import_zod.z.ZodPipe)
+    return getObjectSchema(schema._zod.def.in);
+  return null;
+}
+var INNER_TYPE_WRAPPERS = /* @__PURE__ */ new Set([
+  "optional",
+  "nullable",
+  "default",
+  "prefault",
+  "catch",
+  "nonoptional",
+  "success",
+  "readonly"
+]);
+function getBaseSchemaType(schema) {
+  if (!schema || typeof schema !== "object" || !("_zod" in schema) || !schema._zod?.def?.type) {
+    return null;
+  }
+  const type = schema._zod.def.type;
+  if (INNER_TYPE_WRAPPERS.has(type)) {
+    return getBaseSchemaType(schema._zod.def.innerType);
+  }
+  if (type === "pipe") {
+    return getBaseSchemaType(schema._zod.def.in);
+  }
+  if (type === "literal") {
+    const vals = schema._zod.def.values;
+    if (Array.isArray(vals) && vals.length > 0) {
+      if (vals[0] === null) {
+        return "null";
+      }
+      return typeof vals[0];
+    }
+    return "string";
+  }
+  return type;
+}
+var SnapFormStore = class extends ReactSnapStore {
+  schema;
+  objectSchema;
+  formConfig;
+  _refs = /* @__PURE__ */ new Map();
+  _radioRefs = /* @__PURE__ */ new Map();
+  constructor(schema, initialValues, config) {
+    super({
+      values: { ...initialValues },
+      initial: { ...initialValues },
+      errors: {},
+      submitStatus: { status: asyncStatus("idle"), error: null }
+    });
+    this.schema = schema;
+    this.objectSchema = getObjectSchema(schema);
+    this.formConfig = {
+      validationMode: config?.validationMode ?? "onSubmit"
+    };
+  }
+  get values() {
+    return this.state.get("values");
+  }
+  get errors() {
+    return this.state.get("errors");
+  }
+  get isDirty() {
+    const values = this.state.get("values");
+    const initial = this.state.get("initial");
+    const shapeKeys = this.objectSchema ? Object.keys(this.objectSchema.shape) : [];
+    const allKeys = /* @__PURE__ */ new Set([...Object.keys(initial), ...shapeKeys]);
+    for (const key of allKeys) {
+      if (!this.valuesEqual(values[key], initial[key])) {
+        return true;
+      }
+    }
+    return false;
+  }
+  get isValid() {
+    const errors = this.state.get("errors");
+    return Object.keys(errors).length === 0;
+  }
+  register(field) {
+    const value = this.state.get(`values.${field}`);
+    const isBool = this.getFieldType(field) === "boolean";
+    const trackedEls = /* @__PURE__ */ new Set();
+    return {
+      ref: (el) => {
+        if (el) {
+          if (el.type === "radio") {
+            if (!this._radioRefs.has(field)) this._refs.delete(field);
+            let set = this._radioRefs.get(field);
+            if (!set) {
+              set = /* @__PURE__ */ new Set();
+              this._radioRefs.set(field, set);
+            }
+            set.add(el);
+          } else {
+            this._refs.set(field, el);
+            if (value instanceof Date || Array.isArray(value)) {
+              this.syncValueToDom(field, value);
+            }
+          }
+          trackedEls.add(el);
+        } else {
+          for (const tracked of trackedEls) {
+            const set = this._radioRefs.get(field);
+            if (set) {
+              set.delete(tracked);
+              if (set.size === 0) this._radioRefs.delete(field);
+            } else {
+              this._refs.delete(field);
+            }
+          }
+          trackedEls.clear();
+        }
+      },
+      name: field,
+      ...isBool ? { defaultChecked: Boolean(value) } : Array.isArray(value) ? {} : { defaultValue: value instanceof Date ? this.formatLocalDateTime(value) : String(value ?? "") },
+      onBlur: () => {
+        this.syncRefToState(field);
+        this.handleBlur(field);
+      },
+      onChange: () => {
+        this.syncRefToState(field);
+        this.handleChange(field);
+      }
+    };
+  }
+  getValues() {
+    const stateValues = this.state.get("values");
+    const merged = { ...stateValues };
+    for (const [field, el] of this._refs) {
+      merged[field] = this.coerceRefValue(field, el);
+    }
+    for (const [field] of this._radioRefs) {
+      merged[field] = this.coerceRadioValue(field);
+    }
+    return merged;
+  }
+  getValue(field) {
+    if (this._radioRefs.has(field)) {
+      return this.coerceRadioValue(field);
+    }
+    const el = this._refs.get(field);
+    if (el) return this.coerceRefValue(field, el);
+    return this.state.get(`values.${field}`);
+  }
+  setValue(field, value) {
+    this.state.set(`values.${field}`, value);
+    this.syncValueToDom(field, value);
+    this.handleChange(field);
+  }
+  handleBlur(field) {
+    if (this.formConfig.validationMode === "onBlur") {
+      this.validateField(field);
+    }
+  }
+  handleChange(field) {
+    if (this.formConfig.validationMode === "onChange") {
+      this.validateField(field);
+    }
+  }
+  isFieldDirty(field) {
+    return !this.valuesEqual(
+      this.state.get(`values.${field}`),
+      this.state.get(`initial.${field}`)
+    );
+  }
+  setError(field, message) {
+    const errors = this.state.get("errors");
+    const existing = errors[field] ?? [];
+    this.state.set(`errors.${field}`, [...existing, message]);
+  }
+  clearErrors() {
+    this.state.set("errors", {});
+  }
+  validate() {
+    this.syncFromRefs();
+    const result = this.schema.safeParse(this.state.get("values"));
+    if (result.success) {
+      this.clearErrors();
+      return result.data;
+    }
+    const errors = {};
+    for (const issue of result.error.issues) {
+      const field = issue.path[0];
+      if (!errors[field]) errors[field] = [];
+      errors[field].push(issue.message);
+    }
+    this.state.set("errors", errors);
+    return null;
+  }
+  validateField(field) {
+    if (!this.objectSchema) return;
+    const fieldSchema = this.objectSchema.shape[field];
+    if (!fieldSchema) return;
+    const value = this.state.get(`values.${field}`);
+    const result = fieldSchema.safeParse(value);
+    if (result.success) {
+      const errors = { ...this.state.get("errors") };
+      delete errors[field];
+      this.state.set("errors", errors);
+    } else {
+      const messages = result.error.issues.map(
+        (i) => i.message
+      );
+      this.state.set(`errors.${field}`, messages);
+    }
+  }
+  reset() {
+    const initial = this.state.get("initial");
+    this.state.batch(() => {
+      this.state.set("values", { ...initial });
+      this.state.set("errors", {});
+      this.state.set("submitStatus", { status: asyncStatus("idle"), error: null });
+    });
+    this.syncToDom();
+  }
+  clear() {
+    const initial = this.state.get("initial");
+    const shapeKeys = this.objectSchema ? Object.keys(this.objectSchema.shape) : [];
+    const allKeys = /* @__PURE__ */ new Set([...Object.keys(initial), ...shapeKeys]);
+    const empty = [...allKeys].reduce(
+      (acc, key) => {
+        const val = initial[key];
+        if (val === void 0 || val === null) {
+          const ft = this.getFieldType(key);
+          if (ft === "number") {
+            acc[key] = 0;
+          } else if (ft === "boolean") {
+            acc[key] = false;
+          } else if (ft === "null") {
+            acc[key] = null;
+          } else if (val === null && ft === "string") {
+            acc[key] = "";
+          } else if (val === null && ft === "date") {
+            acc[key] = null;
+          } else if (val === null && ft === "array") {
+            acc[key] = [];
+          } else if (val === null && (ft === "object" || ft === "record")) {
+            acc[key] = {};
+          } else {
+            acc[key] = val;
+          }
+        } else if (val instanceof Date) {
+          acc[key] = null;
+        } else if (typeof val === "number") {
+          acc[key] = 0;
+        } else if (typeof val === "boolean") {
+          acc[key] = false;
+        } else if (Array.isArray(val)) {
+          acc[key] = [];
+        } else if (typeof val === "object") {
+          acc[key] = {};
+        } else {
+          acc[key] = "";
+        }
+        return acc;
+      },
+      {}
+    );
+    this.state.batch(() => {
+      this.state.set("values", empty);
+      this.state.set("errors", {});
+    });
+    this.syncToDom();
+  }
+  setInitialValues(values) {
+    const current = this.state.get("initial");
+    const merged = { ...current, ...values };
+    this.state.batch(() => {
+      this.state.set("values", { ...merged });
+      this.state.set("initial", merged);
+    });
+    this.syncToDom();
+  }
+  valuesEqual(a, b) {
+    if (a === b) return true;
+    if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+    if (Array.isArray(a) && Array.isArray(b)) {
+      return a.length === b.length && a.every((v, i) => v === b[i]);
+    }
+    return false;
+  }
+  getFieldType(field) {
+    const initial = this.state.get("initial");
+    const val = initial[field];
+    if (val instanceof Date) {
+      return "date";
+    }
+    if (Array.isArray(val)) {
+      return "array";
+    }
+    if (val !== void 0 && val !== null) {
+      return typeof val;
+    }
+    if (this.objectSchema) {
+      const base = getBaseSchemaType(this.objectSchema.shape[field]);
+      if (base) {
+        return base;
+      }
+    }
+    return "string";
+  }
+  getArrayItemType(field) {
+    const initial = this.state.get("initial");
+    const val = initial[field];
+    if (Array.isArray(val) && val.length > 0) return typeof val[0];
+    if (this.objectSchema) {
+      let schema = this.objectSchema.shape[field];
+      while (schema?._zod?.def) {
+        if (schema._zod.def.type === "array") {
+          const itemType = getBaseSchemaType(schema._zod.def.element);
+          if (itemType) return itemType;
+          break;
+        }
+        schema = schema._zod.def.innerType ?? schema._zod.def.in;
+        if (!schema) break;
+      }
+    }
+    return "string";
+  }
+  getRadioValue(field) {
+    const set = this._radioRefs.get(field);
+    if (!set) return void 0;
+    for (const el of set) {
+      if (el.checked) return el.value;
+    }
+    return void 0;
+  }
+  formatLocalDateTime(date) {
+    const p = (n) => String(n).padStart(2, "0");
+    return `${date.getFullYear()}-${p(date.getMonth() + 1)}-${p(date.getDate())}T${p(date.getHours())}:${p(date.getMinutes())}`;
+  }
+  formatDateForInput(el, date) {
+    const full = this.formatLocalDateTime(date);
+    if (el.type === "datetime-local") return full;
+    if (el.type === "time") return full.slice(11);
+    return full.slice(0, 10);
+  }
+  coerceStringValue(field, raw) {
+    const typ = this.getFieldType(field);
+    if (typ === "number") return raw === "" ? NaN : Number(raw);
+    if (typ === "date") {
+      if (raw === "") return null;
+      if (/^\d{2}:\d{2}$/.test(raw)) {
+        const [h, m] = raw.split(":").map(Number);
+        const d2 = /* @__PURE__ */ new Date();
+        d2.setHours(h, m, 0, 0);
+        return d2;
+      }
+      if (/^\d{4}-\d{2}-\d{2}$/.test(raw)) {
+        raw = raw + "T00:00:00";
+      }
+      const d = new Date(raw);
+      return isNaN(d.getTime()) ? null : d;
+    }
+    return raw;
+  }
+  coerceRadioValue(field) {
+    const raw = this.getRadioValue(field);
+    if (raw === void 0) return void 0;
+    return this.coerceStringValue(field, raw);
+  }
+  coerceRefValue(field, el) {
+    if (el instanceof HTMLInputElement && el.type === "file") {
+      if (el.files && el.files.length > 0) {
+        return el.multiple ? Array.from(el.files) : el.files[0];
+      }
+      return this.state.get(`values.${field}`);
+    }
+    const typ = this.getFieldType(field);
+    if (typ === "boolean") {
+      return el.checked;
+    }
+    if (typ === "array" && el instanceof HTMLSelectElement && el.multiple) {
+      const itemType = this.getArrayItemType(field);
+      return Array.from(
+        el.selectedOptions,
+        (o) => itemType === "number" ? o.value === "" ? NaN : Number(o.value) : o.value
+      );
+    }
+    return this.coerceStringValue(field, el.value);
+  }
+  syncRefToState(field) {
+    if (this._radioRefs.has(field)) {
+      const val = this.coerceRadioValue(field);
+      if (val !== void 0) {
+        this.state.set(`values.${field}`, val);
+      }
+      return;
+    }
+    const el = this._refs.get(field);
+    if (!el) {
+      return;
+    }
+    this.state.set(`values.${field}`, this.coerceRefValue(field, el));
+  }
+  syncFromRefs() {
+    if (this._refs.size === 0 && this._radioRefs.size === 0) return;
+    this.state.batch(() => {
+      for (const [field, el] of this._refs) {
+        this.state.set(`values.${field}`, this.coerceRefValue(field, el));
+      }
+      for (const [field] of this._radioRefs) {
+        const val = this.coerceRadioValue(field);
+        if (val !== void 0) {
+          this.state.set(`values.${field}`, val);
+        }
+      }
+    });
+  }
+  syncValueToDom(field, value) {
+    const radioSet = this._radioRefs.get(field);
+    if (radioSet) {
+      const strVal = String(value ?? "");
+      for (const el2 of radioSet) {
+        el2.checked = el2.value === strVal;
+      }
+      return;
+    }
+    const el = this._refs.get(field);
+    if (!el) {
+      return;
+    }
+    if (el instanceof HTMLInputElement && el.type === "file") {
+      if (value == null || Array.isArray(value) && value.length === 0) el.value = "";
+      return;
+    }
+    const ft = this.getFieldType(field);
+    if (ft === "boolean") {
+      el.checked = Boolean(value);
+    } else if (ft === "date" && value instanceof Date) {
+      el.value = this.formatDateForInput(el, value);
+    } else if (ft === "array" && el instanceof HTMLSelectElement && el.multiple && Array.isArray(value)) {
+      const vals = new Set(value.map(String));
+      for (let i = 0; i < el.options.length; i++) {
+        el.options[i].selected = vals.has(el.options[i].value);
+      }
+    } else {
+      el.value = String(value ?? "");
+    }
+  }
+  syncToDom() {
+    if (this._refs.size === 0 && this._radioRefs.size === 0) return;
+    const values = this.state.get("values");
+    for (const [field] of this._refs) {
+      this.syncValueToDom(field, values[field]);
+    }
+    for (const [field] of this._radioRefs) {
+      this.syncValueToDom(field, values[field]);
+    }
+  }
+  submit(key, handler) {
+    const data = this.validate();
+    if (!data) return void 0;
+    const promise = this.api.fetch(key, () => handler(data));
+    this.syncSubmitStatus(key);
+    return promise;
+  }
+  syncSubmitStatus(key) {
+    const update = () => {
+      const status = this.getStatus(key);
+      const current = this.state.get("submitStatus");
+      if (current.status === status.status && current.error === status.error)
+        return;
+      this.state.set("submitStatus", status);
+    };
+    update();
+    const unsub = this.subscribe(() => {
+      update();
+      const s = this.getStatus(key).status;
+      if (s.isReady || s.isError) unsub();
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SnapFormStore,
+  asyncStatus,
+  getBaseSchemaType,
+  getObjectSchema,
+  setDefaultHeaders,
+  setHttpClient
+});
+//# sourceMappingURL=index.cjs.map