cogsbox-state 0.5.5 → 0.5.7

package/dist/CogsState.jsx

@@ -1,72 +1,75 @@
 "use client";
-import { j as Y } from "./node_modules/react/jsx-runtime.jsx";
-import { r as w } from "./node_modules/react/index.js";
-import { transformStateFunc as ut, isFunction as at, getNestedValue as R, isDeepEqual as L } from "./utility.js";
-import { pushFunc as Z, cutFunc as K, updateFn as tt, ValidationWrapper as St, FormControlComponent as gt } from "./Functions.jsx";
+import { jsx as at } from "react/jsx-runtime";
+import { useState as Y, useRef as z, useEffect as K, useLayoutEffect as vt, useMemo as It, createElement as H, useSyncExternalStore as pt, startTransition as J } from "react";
+import { transformStateFunc as _t, isFunction as ut, getNestedValue as D, isDeepEqual as L, debounce as Et } from "./utility.js";
+import { pushFunc as it, updateFn as q, cutFunc as st, ValidationWrapper as wt, FormControlComponent as $t } from "./Functions.jsx";
 import "zod";
-import { getGlobalStore as a } from "./store.js";
-import { useCogsConfig as ft } from "./CogsStateClient.jsx";
-import k from "./node_modules/uuid/dist/esm-browser/v4.js";
-function Mt(t, { formElements: i, zodSchema: d }) {
-  return { initialState: t, formElements: i, zodSchema: d };
-}
-function et(t, i) {
-  const d = a.getState().getInitialOptions, u = a.getState().setInitialStateOptions, S = d(t) || {};
-  u(t, {
-    ...S,
+import { getGlobalStore as o, formRefStore as ct } from "./store.js";
+import { useCogsConfig as Vt } from "./CogsStateClient.jsx";
+import tt from "./node_modules/uuid/dist/esm-browser/v4.js";
+function lt(t, i) {
+  const f = o.getState().getInitialOptions, S = o.getState().setInitialStateOptions, g = f(t) || {};
+  S(t, {
+    ...g,
     ...i
   });
 }
-function nt({
+function dt({
   stateKey: t,
   options: i,
-  initialOptionsPart: d
+  initialOptionsPart: f
 }) {
-  const u = z(t) || {}, S = d[t] || {}, I = a.getState().setInitialStateOptions, _ = { ...S, ...u };
-  let E = !1;
+  const S = et(t) || {}, g = f[t] || {}, I = o.getState().setInitialStateOptions, _ = { ...g, ...S };
+  let p = !1;
   if (i)
-    for (const y in i)
-      _.hasOwnProperty(y) || (E = !0, _[y] = i[y]);
-  E && I(t, _);
+    for (const m in i)
+      _.hasOwnProperty(m) || (p = !0, _[m] = i[m]);
+  p && I(t, _);
 }
-const Ot = (t, i) => {
-  let d = t;
-  const [u, S] = ut(d);
-  a.getState().setInitialStates(u);
-  const I = (E, y) => {
-    const [p] = w.useState(k());
-    nt({ stateKey: E, options: y, initialOptionsPart: S });
-    const o = a.getState().cogsStateStore[E] || u[E], r = y?.modifyState ? y.modifyState(o) : o, [v, N] = wt(
-      r,
+const qt = (t, i) => {
+  let f = t;
+  const [S, g] = _t(f);
+  o.getState().setInitialStates(S);
+  const I = (p, m) => {
+    const [E] = Y(m?.componentId ?? tt());
+    dt({
+      stateKey: p,
+      options: m,
+      initialOptionsPart: g
+    });
+    const l = o.getState().cogsStateStore[p] || S[p], e = m?.modifyState ? m.modifyState(l) : l, [v, h] = jt(
+      e,
       {
-        stateKey: E,
-        syncUpdate: y?.syncUpdate,
-        componentId: p,
-        localStorage: y?.localStorage,
-        middleware: y?.middleware,
-        enabledSync: y?.enabledSync,
-        reactiveDeps: y?.reactiveDeps,
-        initState: y?.initState
+        stateKey: p,
+        syncUpdate: m?.syncUpdate,
+        componentId: E,
+        localStorage: m?.localStorage,
+        middleware: m?.middleware,
+        enabledSync: m?.enabledSync,
+        reactiveType: m?.reactiveType,
+        reactiveDeps: m?.reactiveDeps,
+        initState: m?.initState,
+        localStorageKey: m?.localStorageKey
       }
     );
-    return N;
+    return h;
   };
-  function _(E, y) {
-    nt({ stateKey: E, options: y, initialOptionsPart: S });
+  function _(p, m) {
+    dt({ stateKey: p, options: m, initialOptionsPart: g });
   }
   return { useCogsState: I, setCogsOptions: _ };
 }, {
-  setUpdaterState: G,
-  setState: M,
-  getInitialOptions: z,
-  getKeyState: it,
-  getValidationErrors: mt,
-  setStateLog: yt,
-  updateInitialStateGlobal: J,
-  addValidationError: pt,
-  removeValidationError: U,
-  setServerSyncActions: vt
-} = a.getState(), ot = (t) => {
+  setUpdaterState: B,
+  setState: x,
+  getInitialOptions: et,
+  getKeyState: ft,
+  getValidationErrors: Nt,
+  setStateLog: ht,
+  updateInitialStateGlobal: nt,
+  addValidationError: Ct,
+  removeValidationError: R,
+  setServerSyncActions: Tt
+} = o.getState(), gt = (t) => {
   if (!t) return null;
   try {
     const i = window.localStorage.getItem(t);
@@ -74,584 +77,645 @@ const Ot = (t, i) => {
   } catch (i) {
     return console.error("Error loading from localStorage:", i), null;
   }
-}, It = (t, i, d, u) => {
-  if (d?.initState) {
-    const S = {
+}, At = (t, i, f, S) => {
+  if (f.localStorageKey) {
+    const g = {
       state: t,
       lastUpdated: Date.now(),
-      lastSyncedWithServer: a.getState().serverSyncLog[i]?.[0]?.timeStamp,
-      baseServerState: a.getState().serverState[i]
-    }, I = d.initState ? `${u}-${i}-${d.initState.localStorageKey}` : i;
-    window.localStorage.setItem(I, JSON.stringify(S));
+      lastSyncedWithServer: o.getState().serverSyncLog[i]?.[0]?.timeStamp,
+      baseServerState: o.getState().serverState[i]
+    }, I = f.initState ? `${S}-${i}-${f.localStorageKey}` : i;
+    window.localStorage.setItem(I, JSON.stringify(g));
   }
-}, _t = (t, i, d, u, S, I) => {
+}, Ft = (t, i, f, S, g, I) => {
   const _ = {
     initialState: i,
-    updaterState: W(
+    updaterState: Z(
       t,
-      u,
       S,
+      g,
       I
     ),
-    state: d
+    state: f
   };
-  w.startTransition(() => {
-    J(t, _.initialState), G(t, _.updaterState), M(t, _.state);
+  J(() => {
+    nt(t, _.initialState), B(t, _.updaterState), x(t, _.state);
   });
-}, Et = (t) => {
-  const i = a.getState().stateComponents.get(t);
+}, Mt = (t) => {
+  const i = o.getState().stateComponents.get(t);
   if (!i) return;
-  const d = /* @__PURE__ */ new Set();
-  i.components.forEach((u) => {
-    d.add(() => u.forceUpdate());
+  const f = /* @__PURE__ */ new Set();
+  i.components.forEach((S) => {
+    f.add(() => S.forceUpdate());
   }), queueMicrotask(() => {
-    w.startTransition(() => {
-      d.forEach((u) => u());
+    J(() => {
+      f.forEach((S) => S());
     });
   });
+}, zt = (t, i) => {
+  const f = o.getState().stateComponents.get(t);
+  if (f) {
+    const S = `${t}////${i}`, g = f.components.get(S);
+    g && g.forceUpdate();
+  }
 };
-function wt(t, {
+function jt(t, {
   stateKey: i,
-  serverSync: d,
-  zodSchema: u,
+  serverSync: f,
   localStorage: S,
-  formElements: I,
-  middleware: _,
-  reactiveDeps: E,
-  componentId: y,
-  initState: p,
-  syncUpdate: o
+  formElements: g,
+  middleware: I,
+  reactiveDeps: _,
+  reactiveType: p,
+  componentId: m,
+  localStorageKey: E,
+  initState: l,
+  syncUpdate: e
 } = {}) {
-  const [r, v] = w.useState({}), { sessionId: N } = ft();
-  let F = !i;
-  const [c] = w.useState(i ?? k()), b = a.getState().stateLog[c], B = w.useRef(/* @__PURE__ */ new Set()), s = w.useRef(y ?? k()), A = w.useRef(null);
-  A.current = z(c), w.useEffect(() => {
-    if (o && o.stateKey === c && o.path?.[0]) {
-      M(c, (n) => ({
-        ...n,
-        [o.path[0]]: o.newValue
+  const [v, h] = Y({}), { sessionId: F } = Vt();
+  let U = !i;
+  const [d] = Y(i ?? tt()), a = o.getState().stateLog[d], G = z(/* @__PURE__ */ new Set()), b = z(m ?? tt()), A = z(null);
+  A.current = et(d), K(() => {
+    if (e && e.stateKey === d && e.path?.[0]) {
+      x(d, (r) => ({
+        ...r,
+        [e.path[0]]: e.newValue
       }));
-      const e = `${o.stateKey}:${o.path.join(".")}`;
-      a.getState().setSyncInfo(e, {
-        timeStamp: o.timeStamp,
-        userId: o.userId
+      const c = `${e.stateKey}:${e.path.join(".")}`;
+      o.getState().setSyncInfo(c, {
+        timeStamp: e.timeStamp,
+        userId: e.userId
       });
     }
-  }, [o]), w.useEffect(() => {
-    et(c, {
-      initState: p
+  }, [e]), K(() => {
+    lt(d, {
+      initState: l
     });
-    const e = ot(
-      N + "-" + c + "-" + p?.localStorageKey
-    );
-    let n = null;
-    p?.initialState && (n = p?.initialState, e && e.lastUpdated > (e.lastSyncedWithServer || 0) && (n = e.state), _t(
-      c,
-      p?.initialState,
+    let c = null;
+    E && (c = gt(
+      F + "-" + d + "-" + E
+    ));
+    let r = null;
+    l?.initialState && (r = l?.initialState, console.log("newState", r), c && c.lastUpdated > (c.lastSyncedWithServer || 0) && (r = c.state), Ft(
+      d,
+      l?.initialState,
+      r,
       n,
-      h,
-      s.current,
-      N
-    )), Et(c);
-  }, [p?.localStorageKey, ...p?.dependencies || []]), w.useEffect(() => {
-    F && et(c, {
-      serverSync: d,
-      formElements: I,
-      zodSchema: u,
-      initState: p,
+      b.current,
+      F
+    ), console.log("newState222", r), h({}));
+  }, [E, ...l?.dependencies || []]), vt(() => {
+    U && lt(d, {
+      serverSync: f,
+      formElements: g,
+      initState: l,
       localStorage: S,
-      middleware: _
+      middleware: I
     });
-    const e = `${c}////${s.current}`, n = a.getState().stateComponents.get(c) || {
+    const c = `${d}////${b.current}`, r = o.getState().stateComponents.get(d) || {
       components: /* @__PURE__ */ new Map()
     };
-    return n.components.set(e, {
-      forceUpdate: () => v({}),
+    return r.components.set(c, {
+      forceUpdate: () => h({}),
       paths: /* @__PURE__ */ new Set(),
       deps: [],
-      depsFunction: E || void 0
-    }), a.getState().stateComponents.set(c, n), () => {
-      const l = `${c}////${s.current}`;
-      n && (n.components.delete(l), n.components.size === 0 && a.getState().stateComponents.delete(c));
+      depsFunction: _ || void 0,
+      reactiveType: p ?? ["component", "deps"]
+    }), o.getState().stateComponents.set(d, r), h({}), () => {
+      const u = `${d}////${b.current}`;
+      r && (r.components.delete(u), r.components.size === 0 && o.getState().stateComponents.delete(d));
     };
   }, []);
-  const h = (e, n, l, g) => {
-    if (Array.isArray(n)) {
-      const m = `${c}-${n.join(".")}`;
-      B.current.add(m);
+  const n = (c, r, u, w) => {
+    if (Array.isArray(r)) {
+      const M = `${d}-${r.join(".")}`;
+      G.current.add(M);
     }
-    M(c, (m) => {
-      const $ = at(e) ? e(m) : e, P = `${c}-${n.join(".")}`;
-      if (P) {
-        let j = !1, f = a.getState().signalDomElements.get(P);
-        if ((!f || f.size === 0) && (l.updateType === "insert" || l.updateType === "cut")) {
-          const V = n.slice(0, -1), x = R($, V);
-          if (Array.isArray(x)) {
-            j = !0;
-            const T = `${c}-${V.join(".")}`;
-            f = a.getState().signalDomElements.get(T);
+    x(d, (M) => {
+      const V = ut(c) ? c(M) : c, j = `${d}-${r.join(".")}`;
+      if (j) {
+        let P = !1, y = o.getState().signalDomElements.get(j);
+        if ((!y || y.size === 0) && (u.updateType === "insert" || u.updateType === "cut")) {
+          const N = r.slice(0, -1), T = D(V, N);
+          if (Array.isArray(T)) {
+            P = !0;
+            const $ = `${d}-${N.join(".")}`;
+            y = o.getState().signalDomElements.get($);
           }
         }
-        if (f) {
-          const V = j ? R($, n.slice(0, -1)) : R($, n);
-          f.forEach(({ parentId: x, position: T, effect: D }) => {
-            const C = document.querySelector(
-              `[data-parent-id="${x}"]`
+        if (y) {
+          const N = P ? D(V, r.slice(0, -1)) : D(V, r);
+          y.forEach(({ parentId: T, position: $, effect: k }) => {
+            const O = document.querySelector(
+              `[data-parent-id="${T}"]`
             );
-            if (C) {
-              const X = Array.from(C.childNodes);
-              if (X[T]) {
-                const dt = D ? new Function(
-                  "state",
-                  `return (${D})(state)`
-                )(V) : V;
-                X[T].textContent = String(dt);
+            if (O) {
+              const ot = Array.from(O.childNodes);
+              if (ot[$]) {
+                const yt = k ? new Function("state", `return (${k})(state)`)(N) : N;
+                ot[$].textContent = String(yt);
               }
             }
           });
         }
       }
-      l.updateType === "update" && (g || A.current?.validationKey) && n && U(
-        (g || A.current?.validationKey) + "." + n.join(".")
+      u.updateType === "update" && (w || A.current?.validationKey) && r && R(
+        (w || A.current?.validationKey) + "." + r.join(".")
       );
-      const O = n.slice(0, n.length - 1);
-      l.updateType === "cut" && A.current?.validationKey && U(
-        A.current?.validationKey + "." + O.join(".")
-      ), l.updateType === "insert" && A.current?.validationKey && mt(
-        A.current?.validationKey + "." + O.join(".")
-      ).filter(([f, V]) => {
-        let x = f?.split(".").length;
-        if (f == O.join(".") && x == O.length - 1) {
-          let T = f + "." + O;
-          U(f), pt(T, V);
+      const C = r.slice(0, r.length - 1);
+      u.updateType === "cut" && A.current?.validationKey && R(
+        A.current?.validationKey + "." + C.join(".")
+      ), u.updateType === "insert" && A.current?.validationKey && Nt(
+        A.current?.validationKey + "." + C.join(".")
+      ).filter(([y, N]) => {
+        let T = y?.split(".").length;
+        if (y == C.join(".") && T == C.length - 1) {
+          let $ = y + "." + C;
+          R(y), Ct($, N);
         }
       });
-      const st = R(m, n), ct = R($, n), lt = l.updateType === "update" ? n.join(".") : [...n].slice(0, -1).join("."), H = a.getState().stateComponents.get(c);
-      if (H) {
-        for (const [
-          j,
-          f
-        ] of H.components.entries())
-          if (f.depsFunction || f.paths && f.paths.has(lt))
-            if (f.depsFunction) {
-              const V = f.depsFunction($);
-              typeof V == "boolean" ? V && f.forceUpdate() : L(f.deps, V) || (f.deps = V, f.forceUpdate());
-            } else
-              f.forceUpdate();
-      }
-      const Q = {
+      const W = D(M, r), St = D(V, r), mt = u.updateType === "update" ? r.join(".") : [...r].slice(0, -1).join("."), Q = o.getState().stateComponents.get(d);
+      if (i == "cart" && (console.log("thisKey", d), console.log("stateEntry", Q)), Q)
+        for (const [P, y] of Q.components.entries()) {
+          let N = !1;
+          const T = Array.isArray(y.reactiveType) ? y.reactiveType : [y.reactiveType || "component"];
+          if (!T.includes("none")) {
+            if (T.includes("all")) {
+              y.forceUpdate();
+              continue;
+            }
+            if (T.includes("component") && y.paths && (y.paths.has(mt) || y.paths.has("")) && (N = !0), !N && T.includes("deps") && y.depsFunction) {
+              const $ = y.depsFunction(V);
+              typeof $ == "boolean" ? $ && (N = !0) : L(y.deps, $) || (y.deps = $, N = !0);
+            }
+            N && y.forceUpdate();
+          }
+        }
+      const rt = {
         timeStamp: Date.now(),
-        stateKey: c,
-        path: n,
-        updateType: l.updateType,
+        stateKey: d,
+        path: r,
+        updateType: u.updateType,
         status: "new",
-        oldValue: st,
-        newValue: ct
+        oldValue: W,
+        newValue: St
       };
-      if (yt(c, (j) => {
-        const V = [...j ?? [], Q].reduce((x, T) => {
-          const D = `${T.stateKey}:${JSON.stringify(T.path)}`, C = x.get(D);
-          return C ? (C.timeStamp = Math.max(
-            C.timeStamp,
-            T.timeStamp
-          ), C.newValue = T.newValue, C.oldValue = C.oldValue ?? T.oldValue, C.updateType = T.updateType) : x.set(D, { ...T }), x;
+      if (ht(d, (P) => {
+        const N = [...P ?? [], rt].reduce((T, $) => {
+          const k = `${$.stateKey}:${JSON.stringify($.path)}`, O = T.get(k);
+          return O ? (O.timeStamp = Math.max(O.timeStamp, $.timeStamp), O.newValue = $.newValue, O.oldValue = O.oldValue ?? $.oldValue, O.updateType = $.updateType) : T.set(k, { ...$ }), T;
         }, /* @__PURE__ */ new Map());
-        return Array.from(V.values());
-      }), It(
-        $,
-        c,
+        return Array.from(N.values());
+      }), At(
+        V,
+        d,
         A.current,
-        N
-      ), _ && _({ updateLog: b, update: Q }), A.current?.serverSync) {
-        const j = a.getState().serverState[c], f = A.current?.serverSync;
-        vt(c, {
-          syncKey: typeof f.syncKey == "string" ? f.syncKey : f.syncKey({ state: $ }),
-          rollBackState: j,
-          actionTimeStamp: Date.now() + (f.debounce ?? 3e3),
+        F
+      ), I && I({
+        updateLog: a,
+        update: rt
+      }), A.current?.serverSync) {
+        const P = o.getState().serverState[d], y = A.current?.serverSync;
+        Tt(d, {
+          syncKey: typeof y.syncKey == "string" ? y.syncKey : y.syncKey({ state: V }),
+          rollBackState: P,
+          actionTimeStamp: Date.now() + (y.debounce ?? 3e3),
           status: "waiting"
         });
       }
-      return $;
+      return V;
     });
   };
-  a.getState().updaterState[c] || (console.log("Initializing state for", c, t), G(
-    c,
-    W(
-      c,
-      h,
-      s.current,
-      N
+  o.getState().updaterState[d] || (console.log("Initializing state for", d, t), B(
+    d,
+    Z(
+      d,
+      n,
+      b.current,
+      F
     )
-  ), a.getState().cogsStateStore[c] || M(c, t), a.getState().initialStateGlobal[c] || J(c, t));
-  const q = w.useMemo(() => W(
-    c,
-    h,
-    s.current,
-    N
-  ), [c]);
-  return [it(c), q];
+  ), o.getState().cogsStateStore[d] || x(d, t), o.getState().initialStateGlobal[d] || nt(d, t));
+  const s = It(() => Z(
+    d,
+    n,
+    b.current,
+    F
+  ), [d]);
+  return [ft(d), s];
 }
-function W(t, i, d, u) {
-  const S = /* @__PURE__ */ new Map();
+function Z(t, i, f, S) {
+  const g = /* @__PURE__ */ new Map();
   let I = 0;
-  const _ = (o) => {
-    const r = o.join(".");
-    for (const [v] of S)
-      (v === r || v.startsWith(r + ".")) && S.delete(v);
+  const _ = (l) => {
+    const e = l.join(".");
+    for (const [v] of g)
+      (v === e || v.startsWith(e + ".")) && g.delete(v);
     I++;
-  }, E = /* @__PURE__ */ new Map(), y = {
-    removeValidation: (o) => {
-      o?.validationKey && U(o.validationKey);
+  }, p = /* @__PURE__ */ new Map(), m = {
+    removeValidation: (l) => {
+      l?.validationKey && R(l.validationKey);
     },
-    revertToInitialState: (o) => {
-      o?.validationKey && U(o.validationKey);
-      const r = a.getState().initialStateGlobal[t];
-      S.clear(), I++;
-      const v = p(r, []);
-      w.startTransition(() => {
-        G(t, v), M(t, r);
-        const N = a.getState().stateComponents.get(t);
-        N && N.components.forEach((c) => {
-          c.forceUpdate();
+    revertToInitialState: (l) => {
+      const e = o.getState().getInitialOptions(t)?.validation;
+      e?.key && R(e?.key), l?.validationKey && R(l.validationKey);
+      const v = o.getState().initialStateGlobal[t];
+      g.clear(), I++;
+      const h = E(v, []);
+      J(() => {
+        B(t, h), x(t, v);
+        const F = o.getState().stateComponents.get(t);
+        F && F.components.forEach((d) => {
+          d.forceUpdate();
         });
-        const F = z(t);
-        F?.initState && localStorage.removeItem(
-          F?.initState ? u + "-" + t + "-" + F?.initState.localStorageKey : t
+        const U = et(t);
+        U?.localStorageKey && localStorage.removeItem(
+          U?.initState ? S + "-" + t + "-" + U?.localStorageKey : t
         ), localStorage.removeItem(t);
       });
     },
-    updateInitialState: (o) => {
-      S.clear(), I++;
-      const r = W(
+    updateInitialState: (l) => {
+      g.clear(), I++;
+      const e = Z(
         t,
         i,
-        d,
-        u
+        f,
+        S
       );
-      return w.startTransition(() => {
-        J(t, o), G(t, r), M(t, o);
-        const v = a.getState().stateComponents.get(t);
-        v && v.components.forEach((N) => {
-          N.forceUpdate();
+      return J(() => {
+        nt(t, l), B(t, e), x(t, l);
+        const v = o.getState().stateComponents.get(t);
+        v && v.components.forEach((h) => {
+          h.forceUpdate();
         }), localStorage.removeItem(t);
       }), {
-        fetchId: (v) => r.get()[v]
+        fetchId: (v) => e.get()[v]
       };
     },
-    _initialState: a.getState().initialStateGlobal[t],
-    _serverState: a.getState().serverState[t],
-    _isLoading: a.getState().isLoadingGlobal[t],
+    _initialState: o.getState().initialStateGlobal[t],
+    _serverState: o.getState().serverState[t],
+    _isLoading: o.getState().isLoadingGlobal[t],
     _isServerSynced: () => {
-      const o = a.getState().serverState[t];
-      return !!(o && L(o, it(t)));
+      const l = o.getState().serverState[t];
+      return !!(l && L(l, ft(t)));
     }
   };
-  function p(o, r = [], v) {
-    const N = r.map(String).join("."), F = S.get(N);
-    if (F?.stateVersion === I)
-      return F.proxy;
-    const c = {
-      get(B, s) {
-        if (s !== "then" && !s.startsWith("$")) {
-          const e = r.join("."), n = `${t}////${d}`, l = a.getState().stateComponents.get(t);
-          if (l && e) {
-            const g = l.components.get(n);
-            g && g.paths.add(e);
+  function E(l, e = [], v) {
+    const h = e.map(String).join(".");
+    g.get(h);
+    const F = {
+      get(d, a) {
+        if (a !== "then" && !a.startsWith("$") && a !== "stateMapNoRender") {
+          const n = e.join("."), s = `${t}////${f}`, c = o.getState().stateComponents.get(t);
+          if (c) {
+            const r = c.components.get(s);
+            r && (e.length > 0 || a === "get") && r.paths.add(n);
           }
         }
-        if (Array.isArray(o)) {
-          if (s === "getSelected")
+        if (a === "showValidationErrors")
+          return () => {
+            const n = o.getState().getInitialOptions(t)?.validation;
+            if (!n?.key)
+              throw new Error("Validation key not found");
+            return o.getState().getValidationErrors(n.key + "." + e.join("."));
+          };
+        if (Array.isArray(l)) {
+          if (a === "getSelected")
             return () => {
-              const e = E.get(
-                r.join(".")
-              );
-              if (e !== void 0)
-                return p(
-                  o[e],
-                  [...r, e.toString()],
+              const n = p.get(e.join("."));
+              if (n !== void 0)
+                return E(
+                  l[n],
+                  [...e, n.toString()],
                   v
                 );
             };
-          if (s === "stateMap")
-            return (e) => {
-              const n = v?.filtered?.some(
-                (g) => g.join(".") === r.join(".")
-              ), l = n ? o : a.getState().getNestedState(t, r);
-              return S.clear(), I++, l.map((g, m) => {
-                const $ = n && g.__origIndex ? g.__origIndex : m, P = p(
-                  g,
-                  [...r, $.toString()],
+          if (a === "stateMap" || a === "stateMapNoRender")
+            return (n) => {
+              const s = v?.filtered?.some(
+                (r) => r.join(".") === e.join(".")
+              ), c = s ? l : o.getState().getNestedState(t, e);
+              return a !== "stateMapNoRender" && (g.clear(), I++), c.map((r, u) => {
+                const w = s && r.__origIndex ? r.__origIndex : u, M = E(
+                  r,
+                  [...e, w.toString()],
                   v
                 );
-                return e(
-                  g,
-                  P,
-                  m,
-                  o,
-                  p(
-                    o,
-                    r,
-                    v
-                  )
+                return n(
+                  r,
+                  M,
+                  u,
+                  l,
+                  E(l, e, v)
                 );
               });
             };
-          if (s === "$stateMap")
-            return (e) => w.createElement($t, {
+          if (a === "$stateMap")
+            return (n) => H(Ot, {
               proxy: {
                 _stateKey: t,
-                _path: r,
-                _mapFn: e
+                _path: e,
+                _mapFn: n
                 // Pass the actual function, not string
-              }
+              },
+              rebuildStateShape: E
             });
-          if (s === "stateFlattenOn")
-            return (e) => {
-              const l = v?.filtered?.some(
-                (m) => m.join(".") === r.join(".")
-              ) ? o : a.getState().getNestedState(t, r);
-              S.clear(), I++;
-              const g = l.flatMap(
-                (m, $) => m[e] ?? []
+          if (a === "stateFlattenOn")
+            return (n) => {
+              const c = v?.filtered?.some(
+                (u) => u.join(".") === e.join(".")
+              ) ? l : o.getState().getNestedState(t, e);
+              g.clear(), I++;
+              const r = c.flatMap(
+                (u, w) => u[n] ?? []
               );
-              return p(
-                g,
-                [...r, "[*]", e],
+              return E(
+                r,
+                [...e, "[*]", n],
                 v
               );
             };
-          if (s === "findWith")
-            return (e, n) => {
-              const l = o.findIndex(
-                ($) => $[e] === n
+          if (a === "findWith")
+            return (n, s) => {
+              const c = l.findIndex(
+                (w) => w[n] === s
               );
-              if (l === -1) return;
-              const g = o[l], m = [...r, l.toString()];
-              return S.clear(), I++, S.clear(), I++, p(g, m);
+              if (c === -1) return;
+              const r = l[c], u = [...e, c.toString()];
+              return g.clear(), I++, g.clear(), I++, E(r, u);
             };
-          if (s === "index")
-            return (e) => {
-              const n = o[e];
-              return p(n, [
-                ...r,
-                e.toString()
-              ]);
+          if (a === "index")
+            return (n) => {
+              const s = l[n];
+              return E(s, [...e, n.toString()]);
             };
-          if (s === "insert")
-            return (e) => (_(r), Z(
-              i,
-              e,
-              r,
-              t
-            ), p(
-              a.getState().cogsStateStore[t],
+          if (a === "insert")
+            return (n) => (_(e), it(i, n, e, t), E(
+              o.getState().cogsStateStore[t],
               []
             ));
-          if (s === "uniqueInsert")
-            return (e, n) => {
-              const l = a.getState().getNestedState(t, r), g = at(e) ? e(l) : e;
-              !l.some(($) => n ? n.every(
-                (P) => L(
-                  $[P],
-                  g[P]
-                )
-              ) : L($, g)) && (_(r), Z(
-                i,
-                g,
-                r,
-                t
-              ));
+          if (a === "uniqueInsert")
+            return (n, s, c) => {
+              const r = o.getState().getNestedState(t, e), u = ut(n) ? n(r) : n;
+              let w = null;
+              if (!r.some((V) => {
+                if (s) {
+                  const C = s.every(
+                    (W) => L(V[W], u[W])
+                  );
+                  return C && (w = V), C;
+                }
+                const j = L(V, u);
+                return j && (w = V), j;
+              }))
+                _(e), it(i, u, e, t);
+              else if (c && w) {
+                const V = c(w), j = r.map(
+                  (C) => L(C, w) ? V : C
+                );
+                _(e), q(i, j, e);
+              }
             };
-          if (s === "cut")
-            return (e, n) => {
-              n?.waitForSync || (_(r), K(i, r, t, e));
+          if (a === "cut")
+            return (n, s) => {
+              s?.waitForSync || (_(e), st(i, e, t, n));
             };
-          if (s === "stateFilter")
-            return (e) => {
-              const n = o.map(
-                (m, $) => ({
-                  ...m,
-                  __origIndex: $.toString()
-                })
-              ), l = [], g = [];
-              for (let m = 0; m < n.length; m++)
-                e(n[m], m) && (l.push(m), g.push(n[m]));
-              return S.clear(), I++, p(
-                g,
-                r,
-                {
-                  filtered: [...v?.filtered || [], r],
-                  validIndices: l
-                  // Pass through the meta
-                }
-              );
+          if (a === "stateFilter")
+            return (n) => {
+              const s = l.map((u, w) => ({
+                ...u,
+                __origIndex: w.toString()
+              })), c = [], r = [];
+              for (let u = 0; u < s.length; u++)
+                n(s[u], u) && (c.push(u), r.push(s[u]));
+              return g.clear(), I++, E(r, e, {
+                filtered: [...v?.filtered || [], e],
+                validIndices: c
+                // Pass through the meta
+              });
             };
         }
-        const A = r[r.length - 1];
-        if (!isNaN(Number(A))) {
-          const e = r.slice(0, -1), n = a.getState().getNestedState(t, e);
-          if (Array.isArray(n) && s === "cut")
-            return () => K(
+        const G = e[e.length - 1];
+        if (!isNaN(Number(G))) {
+          const n = e.slice(0, -1), s = o.getState().getNestedState(t, n);
+          if (Array.isArray(s) && a === "cut")
+            return () => st(
               i,
-              e,
+              n,
               t,
-              Number(A)
+              Number(G)
             );
         }
-        if (s === "get")
-          return () => a.getState().getNestedState(t, r);
-        if (s === "$effect")
-          return (e) => rt({
+        if (a === "get")
+          return () => o.getState().getNestedState(t, e);
+        if (a === "$derive")
+          return (n) => X({
             _stateKey: t,
-            _path: r,
-            _effect: e.toString()
+            _path: e,
+            _effect: n.toString()
           });
-        if (s === "$get")
-          return () => rt({
+        if (a === "$derive")
+          return (n) => X({
             _stateKey: t,
-            _path: r
+            _path: e,
+            _effect: n.toString()
           });
-        if (s === "lastSynced") {
-          const e = `${t}:${r.join(".")}`;
-          return a.getState().getSyncInfo(e);
+        if (a === "$get")
+          return () => X({
+            _stateKey: t,
+            _path: e
+          });
+        if (a === "lastSynced") {
+          const n = `${t}:${e.join(".")}`;
+          return o.getState().getSyncInfo(n);
         }
-        if (s === "_selected") {
-          const e = r.slice(0, -1), n = e.join("."), l = a.getState().getNestedState(t, e);
-          return Array.isArray(l) ? Number(r[r.length - 1]) === E.get(n) : void 0;
+        if (a === "_selected") {
+          const n = e.slice(0, -1), s = n.join("."), c = o.getState().getNestedState(t, n);
+          return Array.isArray(c) ? Number(e[e.length - 1]) === p.get(s) : void 0;
         }
-        if (s == "getLocalStorage")
-          return (e) => ot(
-            u + "-" + t + "-" + e
-          );
-        if (s === "setSelected")
-          return (e) => {
-            const n = r.slice(0, -1), l = Number(r[r.length - 1]), g = n.join(".");
-            e ? E.set(g, l) : E.delete(g);
-            const m = a.getState().getNestedState(t, [...n]);
-            tt(i, m, n), _(n);
+        if (a == "getLocalStorage")
+          return (n) => gt(S + "-" + t + "-" + n);
+        if (a === "setSelected")
+          return (n) => {
+            const s = e.slice(0, -1), c = Number(e[e.length - 1]), r = s.join(".");
+            n ? p.set(r, c) : p.delete(r);
+            const u = o.getState().getNestedState(t, [...s]);
+            q(i, u, s), _(s);
           };
-        if (r.length == 0) {
-          if (s == "_componentId") return d;
-          if (s === "_initialState")
-            return a.getState().initialStateGlobal[t];
-          if (s === "_serverState")
-            return a.getState().serverState[t];
-          if (s === "_isLoading")
-            return a.getState().isLoadingGlobal[t];
-          if (s === "revertToInitialState")
-            return y.revertToInitialState;
-          if (s === "updateInitialState")
-            return y.updateInitialState;
-          if (s === "removeValidation")
-            return y.removeValidation;
+        if (e.length == 0) {
+          if (a === "validateZodSchema")
+            return () => {
+              const n = o.getState().getInitialOptions(t)?.validation, s = o.getState().addValidationError;
+              if (!n?.zodSchema)
+                throw new Error("Zod schema not found");
+              if (!n?.key)
+                throw new Error("Validation key not found");
+              R(n.key);
+              const c = o.getState().cogsStateStore[t];
+              try {
+                const r = o.getState().getValidationErrors(n.key);
+                r && r.length > 0 && r.forEach(([w]) => {
+                  w && w.startsWith(n.key) && R(w);
+                });
+                const u = n.zodSchema.safeParse(c);
+                return u.success ? !0 : (u.error.errors.forEach((M) => {
+                  const V = M.path, j = M.message, C = [n.key, ...V].join(".");
+                  s(C, j), console.log(
+                    `Validation error at ${C}: ${j}`
+                  );
+                }), Mt(t), !1);
+              } catch (r) {
+                return console.error("Zod schema validation failed", r), !1;
+              }
+            };
+          if (a === "_componentId") return f;
+          if (a === "getComponents")
+            return () => o().stateComponents.get(t);
+          if (a === "getAllFormRefs")
+            return () => ct.getState().getFormRefsByStateKey(t);
+          if (a === "_initialState")
+            return o.getState().initialStateGlobal[t];
+          if (a === "_serverState")
+            return o.getState().serverState[t];
+          if (a === "_isLoading")
+            return o.getState().isLoadingGlobal[t];
+          if (a === "revertToInitialState")
+            return m.revertToInitialState;
+          if (a === "updateInitialState") return m.updateInitialState;
+          if (a === "removeValidation") return m.removeValidation;
         }
-        if (s === "validationWrapper")
+        if (a === "getFormRef")
+          return () => ct.getState().getFormRef(t + "." + e.join("."));
+        if (a === "validationWrapper")
           return ({
-            children: e,
-            hideMessage: n
-          }) => /* @__PURE__ */ Y.jsx(
-            St,
+            children: n,
+            hideMessage: s
+          }) => /* @__PURE__ */ at(
+            wt,
             {
-              formOpts: n ? { validation: { message: "" } } : void 0,
-              path: r,
-              validationKey: a.getState().getInitialOptions(t)?.validationKey || "",
+              formOpts: s ? { validation: { message: "" } } : void 0,
+              path: e,
+              validationKey: o.getState().getInitialOptions(t)?.validation?.key || "",
               stateKey: t,
               validIndices: v?.validIndices,
-              children: e
+              children: n
             }
           );
-        if (s === "_stateKey") return t;
-        if (s === "_path") return r;
-        if (s === "_isServerSynced") return y._isServerSynced;
-        if (s === "update")
-          return (e, n) => {
-            _(r), tt(i, e, r, "");
+        if (a === "_stateKey") return t;
+        if (a === "_path") return e;
+        if (a === "_isServerSynced") return m._isServerSynced;
+        if (a === "update")
+          return (n, s) => {
+            if (s?.debounce)
+              Et(() => {
+                q(i, n, e, "");
+                const c = o.getState().getNestedState(t, e);
+                s?.afterUpdate && s.afterUpdate(c);
+              }, s.debounce);
+            else {
+              q(i, n, e, "");
+              const c = o.getState().getNestedState(t, e);
+              s?.afterUpdate && s.afterUpdate(c);
+            }
+            _(e);
           };
-        if (s === "formElement")
-          return (e, n, l) => /* @__PURE__ */ Y.jsx(
-            gt,
+        if (a === "formElement")
+          return (n, s) => /* @__PURE__ */ at(
+            $t,
             {
               setState: i,
-              validationKey: e,
               stateKey: t,
-              path: r,
+              path: e,
               child: n,
-              formOpts: l
+              formOpts: s
             }
           );
-        const h = [...r, s], q = a.getState().getNestedState(t, h);
-        return p(q, h, v);
+        const b = [...e, a], A = o.getState().getNestedState(t, b);
+        return E(A, b, v);
       }
-    }, b = new Proxy(y, c);
-    return S.set(N, {
-      proxy: b,
+    }, U = new Proxy(m, F);
+    return g.set(h, {
+      proxy: U,
       stateVersion: I
-    }), b;
+    }), U;
   }
-  return p(
-    a.getState().getNestedState(t, [])
+  return E(
+    o.getState().getNestedState(t, [])
   );
 }
-function rt(t) {
-  return w.createElement(Nt, { proxy: t });
+function X(t) {
+  return H(Ut, { proxy: t });
 }
-function $t({
-  proxy: t
+function Ot({
+  proxy: t,
+  rebuildStateShape: i
 }) {
-  const i = a().getNestedState(t._stateKey, t._path);
-  return console.log("value", i), Array.isArray(i) ? i.map((d, u) => t._mapFn(
-    d,
-    a.getState().updaterState[t._stateKey],
-    u,
-    i,
-    a.getState().updaterState[t._stateKey]
-  )) : null;
+  const f = o().getNestedState(t._stateKey, t._path);
+  return console.log("value", f), Array.isArray(f) ? i(
+    f,
+    t._path
+  ).stateMapNoRender(
+    (g, I, _, p, m) => t._mapFn(g, I, _, p, m)
+  ) : null;
 }
-function Nt({
+function Ut({
   proxy: t
 }) {
-  const i = w.useRef(null), d = `${t._stateKey}-${t._path.join(".")}`;
-  return console.log("SignalRenderer", d), w.useEffect(() => {
-    const u = i.current;
-    if (!u || !u.parentElement) return;
-    const S = u.parentElement, _ = Array.from(S.childNodes).indexOf(u);
-    let E = S.getAttribute("data-parent-id");
-    E || (E = `parent-${crypto.randomUUID()}`, S.setAttribute("data-parent-id", E));
-    const p = {
+  const i = z(null), f = `${t._stateKey}-${t._path.join(".")}`;
+  return K(() => {
+    const S = i.current;
+    if (!S || !S.parentElement) return;
+    const g = S.parentElement, _ = Array.from(g.childNodes).indexOf(S);
+    let p = g.getAttribute("data-parent-id");
+    p || (p = `parent-${crypto.randomUUID()}`, g.setAttribute("data-parent-id", p));
+    const E = {
       instanceId: `instance-${crypto.randomUUID()}`,
-      parentId: E,
+      parentId: p,
       position: _,
       effect: t._effect
     };
-    a.getState().addSignalElement(d, p);
-    const o = a.getState().getNestedState(t._stateKey, t._path), r = document.createTextNode(String(o));
-    u.replaceWith(r);
-  }, [t._stateKey, t._path.join("."), t._effect]), w.createElement("span", {
+    o.getState().addSignalElement(f, E);
+    const l = o.getState().getNestedState(t._stateKey, t._path);
+    let e;
+    if (t._effect)
+      try {
+        e = new Function(
+          "state",
+          `return (${t._effect})(state)`
+        )(l);
+      } catch (h) {
+        console.error("Error evaluating effect function during mount:", h), e = l;
+      }
+    else
+      e = l;
+    e !== null && typeof e == "object" && (e = JSON.stringify(e));
+    const v = document.createTextNode(String(e));
+    S.replaceWith(v);
+  }, [t._stateKey, t._path.join("."), t._effect]), H("span", {
     ref: i,
     style: { display: "none" },
-    "data-signal-id": d
+    "data-signal-id": f
   });
 }
-function Dt(t) {
-  const i = w.useSyncExternalStore(
-    (d) => {
-      const u = a.getState().stateComponents.get(t._stateKey) || {
+function Jt(t) {
+  const i = pt(
+    (f) => {
+      const S = o.getState().stateComponents.get(t._stateKey) || {
         components: /* @__PURE__ */ new Map()
       };
-      return u.components.set(t._stateKey, {
-        forceUpdate: d,
+      return S.components.set(t._stateKey, {
+        forceUpdate: f,
         paths: /* @__PURE__ */ new Set([t._path.join(".")])
-      }), () => u.components.delete(t._stateKey);
+      }), () => S.components.delete(t._stateKey);
     },
-    () => a.getState().getNestedState(t._stateKey, t._path)
+    () => o.getState().getNestedState(t._stateKey, t._path)
   );
-  return w.createElement("text", {}, String(i));
+  return H("text", {}, String(i));
 }
 export {
-  rt as $cogsSignal,
-  Dt as $cogsSignalStore,
-  Mt as addStateOptions,
-  Ot as createCogsState,
-  wt as useCogsStateFn
+  X as $cogsSignal,
+  Jt as $cogsSignalStore,
+  qt as createCogsState,
+  zt as notifyComponent,
+  jt as useCogsStateFn
 };
 //# sourceMappingURL=CogsState.jsx.map