cogsbox-state 0.5.354 → 0.5.355

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (4) hide show
  1. package/dist/CogsState.jsx +536 -532
  2. package/dist/CogsState.jsx.map +1 -1
  3. package/package.json +1 -1
  4. package/src/CogsState.tsx +10 -3
package/dist/CogsState.jsx CHANGED
@@ -1,63 +1,63 @@
1
1
  "use client";
2
- import { jsx as mt } from "react/jsx-runtime";
3
- import { useState as X, useRef as Q, useEffect as et, useLayoutEffect as ct, useMemo as ht, createElement as ot, useSyncExternalStore as Vt, startTransition as Pt, useCallback as wt } from "react";
4
- import { transformStateFunc as _t, isDeepEqual as z, isFunction as Y, getNestedValue as q, getDifferences as vt, debounce as Mt } from "./utility.js";
5
- import { pushFunc as St, updateFn as rt, cutFunc as it, ValidationWrapper as Ot, FormControlComponent as Rt } from "./Functions.jsx";
6
- import Ut from "superjson";
7
- import { v4 as It } from "uuid";
2
+ import { jsx as ht } from "react/jsx-runtime";
3
+ import { useState as K, useRef as Z, useEffect as nt, useLayoutEffect as lt, useMemo as vt, createElement as at, useSyncExternalStore as Pt, startTransition as _t, useCallback as At } from "react";
4
+ import { transformStateFunc as Mt, isDeepEqual as B, isFunction as Y, getNestedValue as z, getDifferences as It, debounce as Ot } from "./utility.js";
5
+ import { pushFunc as mt, updateFn as ot, cutFunc as ct, ValidationWrapper as Rt, FormControlComponent as Ut } from "./Functions.jsx";
6
+ import jt from "superjson";
7
+ import { v4 as yt } from "uuid";
8
8
  import "zod";
9
- import { getGlobalStore as r, formRefStore as At } from "./store.js";
10
- import { useCogsConfig as Ct } from "./CogsStateClient.jsx";
11
- import { applyPatch as jt } from "fast-json-patch";
12
- import Lt from "react-use-measure";
13
- function Tt(t, i) {
14
- const h = r.getState().getInitialOptions, f = r.getState().setInitialStateOptions, y = h(t) || {};
9
+ import { getGlobalStore as r, formRefStore as Tt } from "./store.js";
10
+ import { useCogsConfig as bt } from "./CogsStateClient.jsx";
11
+ import { applyPatch as Lt } from "fast-json-patch";
12
+ import Dt from "react-use-measure";
13
+ function Et(t, i) {
14
+ const m = r.getState().getInitialOptions, f = r.getState().setInitialStateOptions, I = m(t) || {};
15
15
  f(t, {
16
- ...y,
16
+ ...I,
17
17
  ...i
18
18
  });
19
19
  }
20
- function Et({
20
+ function $t({
21
21
  stateKey: t,
22
22
  options: i,
23
- initialOptionsPart: h
23
+ initialOptionsPart: m
24
24
  }) {
25
- const f = tt(t) || {}, y = h[t] || {}, b = r.getState().setInitialStateOptions, w = { ...y, ...f };
26
- let p = !1;
25
+ const f = et(t) || {}, I = m[t] || {}, b = r.getState().setInitialStateOptions, p = { ...I, ...f };
26
+ let y = !1;
27
27
  if (i)
28
28
  for (const a in i)
29
- w.hasOwnProperty(a) ? (a == "localStorage" && i[a] && w[a].key !== i[a]?.key && (p = !0, w[a] = i[a]), a == "initialState" && i[a] && w[a] !== i[a] && // Different references
30
- !z(w[a], i[a]) && (p = !0, w[a] = i[a])) : (p = !0, w[a] = i[a]);
31
- p && b(t, w);
29
+ p.hasOwnProperty(a) ? (a == "localStorage" && i[a] && p[a].key !== i[a]?.key && (y = !0, p[a] = i[a]), a == "initialState" && i[a] && p[a] !== i[a] && // Different references
30
+ !B(p[a], i[a]) && (y = !0, p[a] = i[a])) : (y = !0, p[a] = i[a]);
31
+ y && b(t, p);
32
32
  }
33
- function ie(t, { formElements: i, validation: h }) {
34
- return { initialState: t, formElements: i, validation: h };
33
+ function ce(t, { formElements: i, validation: m }) {
34
+ return { initialState: t, formElements: i, validation: m };
35
35
  }
36
- const ce = (t, i) => {
37
- let h = t;
38
- const [f, y] = _t(h);
39
- (Object.keys(y).length > 0 || i && Object.keys(i).length > 0) && Object.keys(y).forEach((p) => {
40
- y[p] = y[p] || {}, y[p].formElements = {
36
+ const le = (t, i) => {
37
+ let m = t;
38
+ const [f, I] = Mt(m);
39
+ (Object.keys(I).length > 0 || i && Object.keys(i).length > 0) && Object.keys(I).forEach((y) => {
40
+ I[y] = I[y] || {}, I[y].formElements = {
41
41
  ...i?.formElements,
42
42
  // Global defaults first
43
43
  ...i?.validation,
44
- ...y[p].formElements || {}
44
+ ...I[y].formElements || {}
45
45
  // State-specific overrides
46
- }, tt(p) || r.getState().setInitialStateOptions(p, y[p]);
46
+ }, et(y) || r.getState().setInitialStateOptions(y, I[y]);
47
47
  }), r.getState().setInitialStates(f), r.getState().setCreatedState(f);
48
- const b = (p, a) => {
49
- const [I] = X(a?.componentId ?? It());
50
- Et({
51
- stateKey: p,
48
+ const b = (y, a) => {
49
+ const [v] = K(a?.componentId ?? yt());
50
+ $t({
51
+ stateKey: y,
52
52
  options: a,
53
- initialOptionsPart: y
53
+ initialOptionsPart: I
54
54
  });
55
- const n = r.getState().cogsStateStore[p] || f[p], m = a?.modifyState ? a.modifyState(n) : n, [G, U] = zt(
56
- m,
55
+ const n = r.getState().cogsStateStore[y] || f[y], S = a?.modifyState ? a.modifyState(n) : n, [F, j] = qt(
56
+ S,
57
57
  {
58
- stateKey: p,
58
+ stateKey: y,
59
59
  syncUpdate: a?.syncUpdate,
60
- componentId: I,
60
+ componentId: v,
61
61
  localStorage: a?.localStorage,
62
62
  middleware: a?.middleware,
63
63
  enabledSync: a?.enabledSync,
@@ -68,49 +68,49 @@ const ce = (t, i) => {
68
68
  serverState: a?.serverState
69
69
  }
70
70
  );
71
- return U;
71
+ return j;
72
72
  };
73
- function w(p, a) {
74
- Et({ stateKey: p, options: a, initialOptionsPart: y }), a.localStorage && Ht(p, a), gt(p);
73
+ function p(y, a) {
74
+ $t({ stateKey: y, options: a, initialOptionsPart: I }), a.localStorage && Bt(y, a), ft(y);
75
75
  }
76
- return { useCogsState: b, setCogsOptions: w };
76
+ return { useCogsState: b, setCogsOptions: p };
77
77
  }, {
78
- setUpdaterState: lt,
79
- setState: K,
80
- getInitialOptions: tt,
81
- getKeyState: bt,
82
- getValidationErrors: Dt,
83
- setStateLog: Ft,
84
- updateInitialStateGlobal: yt,
85
- addValidationError: Gt,
78
+ setUpdaterState: dt,
79
+ setState: tt,
80
+ getInitialOptions: et,
81
+ getKeyState: Nt,
82
+ getValidationErrors: Ft,
83
+ setStateLog: Gt,
84
+ updateInitialStateGlobal: pt,
85
+ addValidationError: Wt,
86
86
  removeValidationError: J,
87
- setServerSyncActions: Wt
88
- } = r.getState(), $t = (t, i, h, f, y) => {
89
- h?.log && console.log(
87
+ setServerSyncActions: Ht
88
+ } = r.getState(), kt = (t, i, m, f, I) => {
89
+ m?.log && console.log(
90
90
  "saving to localstorage",
91
91
  i,
92
- h.localStorage?.key,
92
+ m.localStorage?.key,
93
93
  f
94
94
  );
95
- const b = Y(h?.localStorage?.key) ? h.localStorage?.key(t) : h?.localStorage?.key;
95
+ const b = Y(m?.localStorage?.key) ? m.localStorage?.key(t) : m?.localStorage?.key;
96
96
  if (b && f) {
97
- const w = `${f}-${i}-${b}`;
98
- let p;
97
+ const p = `${f}-${i}-${b}`;
98
+ let y;
99
99
  try {
100
- p = ut(w)?.lastSyncedWithServer;
100
+ y = gt(p)?.lastSyncedWithServer;
101
101
  } catch {
102
102
  }
103
103
  const a = {
104
104
  state: t,
105
105
  lastUpdated: Date.now(),
106
- lastSyncedWithServer: y ?? p
107
- }, I = Ut.serialize(a);
106
+ lastSyncedWithServer: I ?? y
107
+ }, v = jt.serialize(a);
108
108
  window.localStorage.setItem(
109
- w,
110
- JSON.stringify(I.json)
109
+ p,
110
+ JSON.stringify(v.json)
111
111
  );
112
112
  }
113
- }, ut = (t) => {
113
+ }, gt = (t) => {
114
114
  if (!t) return null;
115
115
  try {
116
116
  const i = window.localStorage.getItem(t);
@@ -118,61 +118,61 @@ const ce = (t, i) => {
118
118
  } catch (i) {
119
119
  return console.error("Error loading from localStorage:", i), null;
120
120
  }
121
- }, Ht = (t, i) => {
122
- const h = r.getState().cogsStateStore[t], { sessionId: f } = Ct(), y = Y(i?.localStorage?.key) ? i.localStorage.key(h) : i?.localStorage?.key;
123
- if (y && f) {
124
- const b = ut(
125
- `${f}-${t}-${y}`
121
+ }, Bt = (t, i) => {
122
+ const m = r.getState().cogsStateStore[t], { sessionId: f } = bt(), I = Y(i?.localStorage?.key) ? i.localStorage.key(m) : i?.localStorage?.key;
123
+ if (I && f) {
124
+ const b = gt(
125
+ `${f}-${t}-${I}`
126
126
  );
127
127
  if (b && b.lastUpdated > (b.lastSyncedWithServer || 0))
128
- return K(t, b.state), gt(t), !0;
128
+ return tt(t, b.state), ft(t), !0;
129
129
  }
130
130
  return !1;
131
- }, Nt = (t, i, h, f, y, b) => {
132
- const w = {
131
+ }, xt = (t, i, m, f, I, b) => {
132
+ const p = {
133
133
  initialState: i,
134
- updaterState: dt(
134
+ updaterState: ut(
135
135
  t,
136
136
  f,
137
- y,
137
+ I,
138
138
  b
139
139
  ),
140
- state: h
140
+ state: m
141
141
  };
142
- yt(t, w.initialState), lt(t, w.updaterState), K(t, w.state);
143
- }, gt = (t) => {
142
+ pt(t, p.initialState), dt(t, p.updaterState), tt(t, p.state);
143
+ }, ft = (t) => {
144
144
  const i = r.getState().stateComponents.get(t);
145
145
  if (!i) return;
146
- const h = /* @__PURE__ */ new Set();
146
+ const m = /* @__PURE__ */ new Set();
147
147
  i.components.forEach((f) => {
148
- (f ? Array.isArray(f.reactiveType) ? f.reactiveType : [f.reactiveType || "component"] : null)?.includes("none") || h.add(() => f.forceUpdate());
148
+ (f ? Array.isArray(f.reactiveType) ? f.reactiveType : [f.reactiveType || "component"] : null)?.includes("none") || m.add(() => f.forceUpdate());
149
149
  }), queueMicrotask(() => {
150
- h.forEach((f) => f());
150
+ m.forEach((f) => f());
151
151
  });
152
- }, le = (t, i) => {
153
- const h = r.getState().stateComponents.get(t);
154
- if (h) {
155
- const f = `${t}////${i}`, y = h.components.get(f);
156
- if ((y ? Array.isArray(y.reactiveType) ? y.reactiveType : [y.reactiveType || "component"] : null)?.includes("none"))
152
+ }, de = (t, i) => {
153
+ const m = r.getState().stateComponents.get(t);
154
+ if (m) {
155
+ const f = `${t}////${i}`, I = m.components.get(f);
156
+ if ((I ? Array.isArray(I.reactiveType) ? I.reactiveType : [I.reactiveType || "component"] : null)?.includes("none"))
157
157
  return;
158
- y && y.forceUpdate();
158
+ I && I.forceUpdate();
159
159
  }
160
- }, Bt = (t, i, h, f) => {
160
+ }, zt = (t, i, m, f) => {
161
161
  switch (t) {
162
162
  case "update":
163
163
  return {
164
- oldValue: q(i, f),
165
- newValue: q(h, f)
164
+ oldValue: z(i, f),
165
+ newValue: z(m, f)
166
166
  };
167
167
  case "insert":
168
168
  return {
169
169
  oldValue: null,
170
170
  // or undefined
171
- newValue: q(h, f)
171
+ newValue: z(m, f)
172
172
  };
173
173
  case "cut":
174
174
  return {
175
- oldValue: q(i, f),
175
+ oldValue: z(i, f),
176
176
  newValue: null
177
177
  // or undefined
178
178
  };
@@ -180,235 +180,235 @@ const ce = (t, i) => {
180
180
  return { oldValue: null, newValue: null };
181
181
  }
182
182
  };
183
- function zt(t, {
183
+ function qt(t, {
184
184
  stateKey: i,
185
- serverSync: h,
185
+ serverSync: m,
186
186
  localStorage: f,
187
- formElements: y,
187
+ formElements: I,
188
188
  reactiveDeps: b,
189
- reactiveType: w,
190
- componentId: p,
189
+ reactiveType: p,
190
+ componentId: y,
191
191
  initialState: a,
192
- syncUpdate: I,
192
+ syncUpdate: v,
193
193
  dependencies: n,
194
- serverState: m
194
+ serverState: S
195
195
  } = {}) {
196
- const [G, U] = X({}), { sessionId: j } = Ct();
197
- let W = !i;
198
- const [v] = X(i ?? It()), l = r.getState().stateLog[v], at = Q(/* @__PURE__ */ new Set()), Z = Q(p ?? It()), O = Q(
196
+ const [F, j] = K({}), { sessionId: L } = bt();
197
+ let G = !i;
198
+ const [h] = K(i ?? yt()), l = r.getState().stateLog[h], st = Z(/* @__PURE__ */ new Set()), X = Z(y ?? yt()), R = Z(
199
199
  null
200
200
  );
201
- O.current = tt(v) ?? null, et(() => {
202
- if (I && I.stateKey === v && I.path?.[0]) {
203
- K(v, (o) => ({
201
+ R.current = et(h) ?? null, nt(() => {
202
+ if (v && v.stateKey === h && v.path?.[0]) {
203
+ tt(h, (o) => ({
204
204
  ...o,
205
- [I.path[0]]: I.newValue
205
+ [v.path[0]]: v.newValue
206
206
  }));
207
- const e = `${I.stateKey}:${I.path.join(".")}`;
207
+ const e = `${v.stateKey}:${v.path.join(".")}`;
208
208
  r.getState().setSyncInfo(e, {
209
- timeStamp: I.timeStamp,
210
- userId: I.userId
209
+ timeStamp: v.timeStamp,
210
+ userId: v.userId
211
211
  });
212
212
  }
213
- }, [I]), et(() => {
213
+ }, [v]), nt(() => {
214
214
  if (a) {
215
- Tt(v, {
215
+ Et(h, {
216
216
  initialState: a
217
217
  });
218
- const e = O.current, s = e?.serverState?.id !== void 0 && e?.serverState?.status === "success" && e?.serverState?.data, c = r.getState().initialStateGlobal[v];
219
- if (!(c && !z(c, a) || !c) && !s)
218
+ const e = R.current, s = e?.serverState?.id !== void 0 && e?.serverState?.status === "success" && e?.serverState?.data, c = r.getState().initialStateGlobal[h];
219
+ if (!(c && !B(c, a) || !c) && !s)
220
220
  return;
221
221
  let u = null;
222
222
  const T = Y(e?.localStorage?.key) ? e?.localStorage?.key(a) : e?.localStorage?.key;
223
- T && j && (u = ut(`${j}-${v}-${T}`));
224
- let A = a, E = !1;
225
- const _ = s ? Date.now() : 0, x = u?.lastUpdated || 0, $ = u?.lastSyncedWithServer || 0;
226
- s && _ > x ? (A = e.serverState.data, E = !0) : u && x > $ && (A = u.state, e?.localStorage?.onChange && e?.localStorage?.onChange(A)), r.getState().initializeShadowState(v, a), Nt(
227
- v,
223
+ T && L && (u = gt(`${L}-${h}-${T}`));
224
+ let w = a, E = !1;
225
+ const M = s ? Date.now() : 0, P = u?.lastUpdated || 0, O = u?.lastSyncedWithServer || 0;
226
+ s && M > P ? (w = e.serverState.data, E = !0) : u && P > O && (w = u.state, e?.localStorage?.onChange && e?.localStorage?.onChange(w)), r.getState().initializeShadowState(h, a), xt(
227
+ h,
228
228
  a,
229
- A,
230
- nt,
231
- Z.current,
232
- j
233
- ), E && T && j && $t(A, v, e, j, Date.now()), gt(v), (Array.isArray(w) ? w : [w || "component"]).includes("none") || U({});
229
+ w,
230
+ rt,
231
+ X.current,
232
+ L
233
+ ), E && T && L && kt(w, h, e, L, Date.now()), ft(h), (Array.isArray(p) ? p : [p || "component"]).includes("none") || j({});
234
234
  }
235
235
  }, [
236
236
  a,
237
- m?.status,
238
- m?.data,
237
+ S?.status,
238
+ S?.data,
239
239
  ...n || []
240
- ]), ct(() => {
241
- W && Tt(v, {
242
- serverSync: h,
243
- formElements: y,
240
+ ]), lt(() => {
241
+ G && Et(h, {
242
+ serverSync: m,
243
+ formElements: I,
244
244
  initialState: a,
245
245
  localStorage: f,
246
- middleware: O.current?.middleware
246
+ middleware: R.current?.middleware
247
247
  });
248
- const e = `${v}////${Z.current}`, o = r.getState().stateComponents.get(v) || {
248
+ const e = `${h}////${X.current}`, o = r.getState().stateComponents.get(h) || {
249
249
  components: /* @__PURE__ */ new Map()
250
250
  };
251
251
  return o.components.set(e, {
252
- forceUpdate: () => U({}),
252
+ forceUpdate: () => j({}),
253
253
  paths: /* @__PURE__ */ new Set(),
254
254
  deps: [],
255
255
  depsFunction: b || void 0,
256
- reactiveType: w ?? ["component", "deps"]
257
- }), r.getState().stateComponents.set(v, o), U({}), () => {
258
- o && (o.components.delete(e), o.components.size === 0 && r.getState().stateComponents.delete(v));
256
+ reactiveType: p ?? ["component", "deps"]
257
+ }), r.getState().stateComponents.set(h, o), j({}), () => {
258
+ o && (o.components.delete(e), o.components.size === 0 && r.getState().stateComponents.delete(h));
259
259
  };
260
260
  }, []);
261
- const nt = (e, o, s, c) => {
261
+ const rt = (e, o, s, c) => {
262
262
  if (Array.isArray(o)) {
263
- const u = `${v}-${o.join(".")}`;
264
- at.current.add(u);
263
+ const u = `${h}-${o.join(".")}`;
264
+ st.current.add(u);
265
265
  }
266
266
  const g = r.getState();
267
- K(v, (u) => {
268
- const T = Y(e) ? e(u) : e, A = `${v}-${o.join(".")}`;
269
- if (A) {
270
- let M = !1, N = g.signalDomElements.get(A);
267
+ tt(h, (u) => {
268
+ const T = Y(e) ? e(u) : e, w = `${h}-${o.join(".")}`;
269
+ if (w) {
270
+ let V = !1, N = g.signalDomElements.get(w);
271
271
  if ((!N || N.size === 0) && (s.updateType === "insert" || s.updateType === "cut")) {
272
- const R = o.slice(0, -1), D = q(T, R);
272
+ const U = o.slice(0, -1), D = z(T, U);
273
273
  if (Array.isArray(D)) {
274
- M = !0;
275
- const S = `${v}-${R.join(".")}`;
276
- N = g.signalDomElements.get(S);
274
+ V = !0;
275
+ const $ = `${h}-${U.join(".")}`;
276
+ N = g.signalDomElements.get($);
277
277
  }
278
278
  }
279
279
  if (N) {
280
- const R = M ? q(T, o.slice(0, -1)) : q(T, o);
281
- N.forEach(({ parentId: D, position: S, effect: k }) => {
282
- const C = document.querySelector(
280
+ const U = V ? z(T, o.slice(0, -1)) : z(T, o);
281
+ N.forEach(({ parentId: D, position: $, effect: A }) => {
282
+ const k = document.querySelector(
283
283
  `[data-parent-id="${D}"]`
284
284
  );
285
- if (C) {
286
- const V = Array.from(C.childNodes);
287
- if (V[S]) {
288
- const P = k ? new Function("state", `return (${k})(state)`)(R) : R;
289
- V[S].textContent = String(P);
285
+ if (k) {
286
+ const _ = Array.from(k.childNodes);
287
+ if (_[$]) {
288
+ const C = A ? new Function("state", `return (${A})(state)`)(U) : U;
289
+ _[$].textContent = String(C);
290
290
  }
291
291
  }
292
292
  });
293
293
  }
294
294
  }
295
- console.log("shadowState", g.shadowStateStore), s.updateType === "update" && (c || O.current?.validation?.key) && o && J(
296
- (c || O.current?.validation?.key) + "." + o.join(".")
295
+ console.log("shadowState", g.shadowStateStore), s.updateType === "update" && (c || R.current?.validation?.key) && o && J(
296
+ (c || R.current?.validation?.key) + "." + o.join(".")
297
297
  );
298
298
  const E = o.slice(0, o.length - 1);
299
- s.updateType === "cut" && O.current?.validation?.key && J(
300
- O.current?.validation?.key + "." + E.join(".")
301
- ), s.updateType === "insert" && O.current?.validation?.key && Dt(
302
- O.current?.validation?.key + "." + E.join(".")
303
- ).filter(([N, R]) => {
299
+ s.updateType === "cut" && R.current?.validation?.key && J(
300
+ R.current?.validation?.key + "." + E.join(".")
301
+ ), s.updateType === "insert" && R.current?.validation?.key && Ft(
302
+ R.current?.validation?.key + "." + E.join(".")
303
+ ).filter(([N, U]) => {
304
304
  let D = N?.split(".").length;
305
305
  if (N == E.join(".") && D == E.length - 1) {
306
- let S = N + "." + E;
307
- J(N), Gt(S, R);
306
+ let $ = N + "." + E;
307
+ J(N), Wt($, U);
308
308
  }
309
309
  });
310
- const _ = g.stateComponents.get(v);
311
- if (console.log("stateEntry >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>", _), _) {
312
- const M = vt(u, T), N = new Set(M), R = s.updateType === "update" ? o.join(".") : o.slice(0, -1).join(".") || "";
310
+ const M = g.stateComponents.get(h);
311
+ if (console.log("stateEntry >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>", M), M) {
312
+ const V = It(u, T), N = new Set(V), U = s.updateType === "update" ? o.join(".") : o.slice(0, -1).join(".") || "";
313
313
  for (const [
314
314
  D,
315
- S
316
- ] of _.components.entries()) {
317
- let k = !1;
318
- const C = Array.isArray(S.reactiveType) ? S.reactiveType : [S.reactiveType || "component"];
319
- if (console.log("component", S), !C.includes("none")) {
320
- if (C.includes("all")) {
321
- S.forceUpdate();
315
+ $
316
+ ] of M.components.entries()) {
317
+ let A = !1;
318
+ const k = Array.isArray($.reactiveType) ? $.reactiveType : [$.reactiveType || "component"];
319
+ if (console.log("component", $), !k.includes("none")) {
320
+ if (k.includes("all")) {
321
+ $.forceUpdate();
322
322
  continue;
323
323
  }
324
- if (C.includes("component") && ((S.paths.has(R) || S.paths.has("")) && (k = !0), !k))
325
- for (const V of N) {
326
- let P = V;
324
+ if (k.includes("component") && (($.paths.has(U) || $.paths.has("")) && (A = !0), !A))
325
+ for (const _ of N) {
326
+ let C = _;
327
327
  for (; ; ) {
328
- if (S.paths.has(P)) {
329
- k = !0;
328
+ if ($.paths.has(C)) {
329
+ A = !0;
330
330
  break;
331
331
  }
332
- const H = P.lastIndexOf(".");
333
- if (H !== -1) {
334
- const B = P.substring(
332
+ const W = C.lastIndexOf(".");
333
+ if (W !== -1) {
334
+ const q = C.substring(
335
335
  0,
336
- H
336
+ W
337
337
  );
338
338
  if (!isNaN(
339
- Number(P.substring(H + 1))
340
- ) && S.paths.has(B)) {
341
- k = !0;
339
+ Number(C.substring(W + 1))
340
+ ) && $.paths.has(q)) {
341
+ A = !0;
342
342
  break;
343
343
  }
344
- P = B;
344
+ C = q;
345
345
  } else
346
- P = "";
347
- if (P === "")
346
+ C = "";
347
+ if (C === "")
348
348
  break;
349
349
  }
350
- if (k) break;
350
+ if (A) break;
351
351
  }
352
- if (!k && C.includes("deps") && S.depsFunction) {
353
- const V = S.depsFunction(T);
354
- let P = !1;
355
- typeof V == "boolean" ? V && (P = !0) : z(S.deps, V) || (S.deps = V, P = !0), P && (k = !0);
352
+ if (!A && k.includes("deps") && $.depsFunction) {
353
+ const _ = $.depsFunction(T);
354
+ let C = !1;
355
+ typeof _ == "boolean" ? _ && (C = !0) : B($.deps, _) || ($.deps = _, C = !0), C && (A = !0);
356
356
  }
357
- k && S.forceUpdate();
357
+ A && $.forceUpdate();
358
358
  }
359
359
  }
360
360
  }
361
- const x = Date.now();
362
- o = o.map((M, N) => {
363
- const R = o.slice(0, -1), D = q(T, R);
364
- return N === o.length - 1 && ["insert", "cut"].includes(s.updateType) ? (D.length - 1).toString() : M;
361
+ const P = Date.now();
362
+ o = o.map((V, N) => {
363
+ const U = o.slice(0, -1), D = z(T, U);
364
+ return N === o.length - 1 && ["insert", "cut"].includes(s.updateType) ? (D.length - 1).toString() : V;
365
365
  });
366
- const { oldValue: $, newValue: F } = Bt(
366
+ const { oldValue: O, newValue: x } = zt(
367
367
  s.updateType,
368
368
  u,
369
369
  T,
370
370
  o
371
- ), L = {
372
- timeStamp: x,
373
- stateKey: v,
371
+ ), H = {
372
+ timeStamp: P,
373
+ stateKey: h,
374
374
  path: o,
375
375
  updateType: s.updateType,
376
376
  status: "new",
377
- oldValue: $,
378
- newValue: F
377
+ oldValue: O,
378
+ newValue: x
379
379
  };
380
380
  switch (s.updateType) {
381
381
  case "update":
382
- g.updateShadowAtPath(v, o, T);
382
+ g.updateShadowAtPath(h, o, T);
383
383
  break;
384
384
  case "insert":
385
- const M = o.slice(0, -1);
386
- g.insertShadowArrayElement(v, M, F);
385
+ const V = o.slice(0, -1);
386
+ g.insertShadowArrayElement(h, V, x);
387
387
  break;
388
388
  case "cut":
389
- const N = o.slice(0, -1), R = parseInt(o[o.length - 1]);
390
- g.removeShadowArrayElement(v, N, R);
389
+ const N = o.slice(0, -1), U = parseInt(o[o.length - 1]);
390
+ g.removeShadowArrayElement(h, N, U);
391
391
  break;
392
392
  }
393
- if (Ft(v, (M) => {
394
- const R = [...M ?? [], L].reduce((D, S) => {
395
- const k = `${S.stateKey}:${JSON.stringify(S.path)}`, C = D.get(k);
396
- return C ? (C.timeStamp = Math.max(C.timeStamp, S.timeStamp), C.newValue = S.newValue, C.oldValue = C.oldValue ?? S.oldValue, C.updateType = S.updateType) : D.set(k, { ...S }), D;
393
+ if (Gt(h, (V) => {
394
+ const U = [...V ?? [], H].reduce((D, $) => {
395
+ const A = `${$.stateKey}:${JSON.stringify($.path)}`, k = D.get(A);
396
+ return k ? (k.timeStamp = Math.max(k.timeStamp, $.timeStamp), k.newValue = $.newValue, k.oldValue = k.oldValue ?? $.oldValue, k.updateType = $.updateType) : D.set(A, { ...$ }), D;
397
397
  }, /* @__PURE__ */ new Map());
398
- return Array.from(R.values());
399
- }), $t(
398
+ return Array.from(U.values());
399
+ }), kt(
400
400
  T,
401
- v,
402
- O.current,
403
- j
404
- ), O.current?.middleware && O.current.middleware({
401
+ h,
402
+ R.current,
403
+ L
404
+ ), R.current?.middleware && R.current.middleware({
405
405
  updateLog: l,
406
- update: L
407
- }), O.current?.serverSync) {
408
- const M = g.serverState[v], N = O.current?.serverSync;
409
- Wt(v, {
406
+ update: H
407
+ }), R.current?.serverSync) {
408
+ const V = g.serverState[h], N = R.current?.serverSync;
409
+ Ht(h, {
410
410
  syncKey: typeof N.syncKey == "string" ? N.syncKey : N.syncKey({ state: T }),
411
- rollBackState: M,
411
+ rollBackState: V,
412
412
  actionTimeStamp: Date.now() + (N.debounce ?? 3e3),
413
413
  status: "waiting"
414
414
  });
@@ -416,91 +416,91 @@ function zt(t, {
416
416
  return T;
417
417
  });
418
418
  };
419
- r.getState().updaterState[v] || (lt(
420
- v,
421
- dt(
422
- v,
423
- nt,
424
- Z.current,
425
- j
419
+ r.getState().updaterState[h] || (dt(
420
+ h,
421
+ ut(
422
+ h,
423
+ rt,
424
+ X.current,
425
+ L
426
426
  )
427
- ), r.getState().cogsStateStore[v] || K(v, t), r.getState().initialStateGlobal[v] || yt(v, t));
428
- const d = ht(() => dt(
429
- v,
430
- nt,
431
- Z.current,
432
- j
433
- ), [v, j]);
434
- return [bt(v), d];
427
+ ), r.getState().cogsStateStore[h] || tt(h, t), r.getState().initialStateGlobal[h] || pt(h, t));
428
+ const d = vt(() => ut(
429
+ h,
430
+ rt,
431
+ X.current,
432
+ L
433
+ ), [h, L]);
434
+ return [Nt(h), d];
435
435
  }
436
- function dt(t, i, h, f) {
437
- const y = /* @__PURE__ */ new Map();
436
+ function ut(t, i, m, f) {
437
+ const I = /* @__PURE__ */ new Map();
438
438
  let b = 0;
439
- const w = (I) => {
440
- const n = I.join(".");
441
- for (const [m] of y)
442
- (m === n || m.startsWith(n + ".")) && y.delete(m);
439
+ const p = (v) => {
440
+ const n = v.join(".");
441
+ for (const [S] of I)
442
+ (S === n || S.startsWith(n + ".")) && I.delete(S);
443
443
  b++;
444
- }, p = {
445
- removeValidation: (I) => {
446
- I?.validationKey && J(I.validationKey);
444
+ }, y = {
445
+ removeValidation: (v) => {
446
+ v?.validationKey && J(v.validationKey);
447
447
  },
448
- revertToInitialState: (I) => {
448
+ revertToInitialState: (v) => {
449
449
  const n = r.getState().getInitialOptions(t)?.validation;
450
- n?.key && J(n?.key), I?.validationKey && J(I.validationKey);
451
- const m = r.getState().initialStateGlobal[t];
452
- r.getState().clearSelectedIndexesForState(t), y.clear(), b++;
453
- const G = a(m, []), U = tt(t), j = Y(U?.localStorage?.key) ? U?.localStorage?.key(m) : U?.localStorage?.key, W = `${f}-${t}-${j}`;
454
- W && localStorage.removeItem(W), lt(t, G), K(t, m);
455
- const v = r.getState().stateComponents.get(t);
456
- return v && v.components.forEach((l) => {
450
+ n?.key && J(n?.key), v?.validationKey && J(v.validationKey);
451
+ const S = r.getState().initialStateGlobal[t];
452
+ r.getState().clearSelectedIndexesForState(t), I.clear(), b++;
453
+ const F = a(S, []), j = et(t), L = Y(j?.localStorage?.key) ? j?.localStorage?.key(S) : j?.localStorage?.key, G = `${f}-${t}-${L}`;
454
+ G && localStorage.removeItem(G), dt(t, F), tt(t, S);
455
+ const h = r.getState().stateComponents.get(t);
456
+ return h && h.components.forEach((l) => {
457
457
  l.forceUpdate();
458
- }), m;
458
+ }), S;
459
459
  },
460
- updateInitialState: (I) => {
461
- y.clear(), b++;
462
- const n = dt(
460
+ updateInitialState: (v) => {
461
+ I.clear(), b++;
462
+ const n = ut(
463
463
  t,
464
464
  i,
465
- h,
465
+ m,
466
466
  f
467
- ), m = r.getState().initialStateGlobal[t], G = tt(t), U = Y(G?.localStorage?.key) ? G?.localStorage?.key(m) : G?.localStorage?.key, j = `${f}-${t}-${U}`;
468
- return localStorage.getItem(j) && localStorage.removeItem(j), Pt(() => {
469
- yt(t, I), r.getState().initializeShadowState(t, I), lt(t, n), K(t, I);
470
- const W = r.getState().stateComponents.get(t);
471
- W && W.components.forEach((v) => {
472
- v.forceUpdate();
467
+ ), S = r.getState().initialStateGlobal[t], F = et(t), j = Y(F?.localStorage?.key) ? F?.localStorage?.key(S) : F?.localStorage?.key, L = `${f}-${t}-${j}`;
468
+ return localStorage.getItem(L) && localStorage.removeItem(L), _t(() => {
469
+ pt(t, v), r.getState().initializeShadowState(t, v), dt(t, n), tt(t, v);
470
+ const G = r.getState().stateComponents.get(t);
471
+ G && G.components.forEach((h) => {
472
+ h.forceUpdate();
473
473
  });
474
474
  }), {
475
- fetchId: (W) => n.get()[W]
475
+ fetchId: (G) => n.get()[G]
476
476
  };
477
477
  },
478
478
  _initialState: r.getState().initialStateGlobal[t],
479
479
  _serverState: r.getState().serverState[t],
480
480
  _isLoading: r.getState().isLoadingGlobal[t],
481
481
  _isServerSynced: () => {
482
- const I = r.getState().serverState[t];
483
- return !!(I && z(I, bt(t)));
482
+ const v = r.getState().serverState[t];
483
+ return !!(v && B(v, Nt(t)));
484
484
  }
485
485
  };
486
- function a(I, n = [], m) {
487
- const G = n.map(String).join(".");
488
- y.get(G);
489
- const U = function() {
486
+ function a(v, n = [], S) {
487
+ const F = n.map(String).join(".");
488
+ I.get(F);
489
+ const j = function() {
490
490
  return r().getNestedState(t, n);
491
491
  };
492
- Object.keys(p).forEach((v) => {
493
- U[v] = p[v];
492
+ Object.keys(y).forEach((h) => {
493
+ j[h] = y[h];
494
494
  });
495
- const j = {
496
- apply(v, l, at) {
495
+ const L = {
496
+ apply(h, l, st) {
497
497
  return console.log(
498
498
  `PROXY APPLY TRAP HIT: stateKey=${t}, path=${n.join(".")}`
499
499
  ), console.trace("Apply trap stack trace"), r().getNestedState(t, n);
500
500
  },
501
- get(v, l) {
502
- m?.validIndices && !Array.isArray(I) && (m = { ...m, validIndices: void 0 });
503
- const at = /* @__PURE__ */ new Set([
501
+ get(h, l) {
502
+ S?.validIndices && !Array.isArray(v) && (S = { ...S, validIndices: void 0 });
503
+ const st = /* @__PURE__ */ new Set([
504
504
  "insert",
505
505
  "cut",
506
506
  "cutByValue",
@@ -523,8 +523,8 @@ function dt(t, i, h, f) {
523
523
  "_stateKey",
524
524
  "getComponents"
525
525
  ]);
526
- if (l !== "then" && !l.startsWith("$") && l !== "stateMapNoRender" && !at.has(l)) {
527
- const d = `${t}////${h}`, e = r.getState().stateComponents.get(t);
526
+ if (l !== "then" && !l.startsWith("$") && l !== "stateMapNoRender" && !st.has(l)) {
527
+ const d = `${t}////${m}`, e = r.getState().stateComponents.get(t);
528
528
  if (e) {
529
529
  const o = e.components.get(d);
530
530
  if (o && !o.paths.has("")) {
@@ -540,7 +540,7 @@ function dt(t, i, h, f) {
540
540
  }
541
541
  }
542
542
  if (l === "getDifferences")
543
- return () => vt(
543
+ return () => It(
544
544
  r.getState().cogsStateStore[t],
545
545
  r.getState().initialStateGlobal[t]
546
546
  );
@@ -568,20 +568,20 @@ function dt(t, i, h, f) {
568
568
  }
569
569
  };
570
570
  if (l === "_status") {
571
- const d = r.getState().getNestedState(t, n), e = r.getState().initialStateGlobal[t], o = q(e, n);
572
- return z(d, o) ? "fresh" : "stale";
571
+ const d = r.getState().getNestedState(t, n), e = r.getState().initialStateGlobal[t], o = z(e, n);
572
+ return B(d, o) ? "fresh" : "stale";
573
573
  }
574
574
  if (l === "getStatus")
575
575
  return function() {
576
576
  const d = r().getNestedState(
577
577
  t,
578
578
  n
579
- ), e = r.getState().initialStateGlobal[t], o = q(e, n);
580
- return z(d, o) ? "fresh" : "stale";
579
+ ), e = r.getState().initialStateGlobal[t], o = z(e, n);
580
+ return B(d, o) ? "fresh" : "stale";
581
581
  };
582
582
  if (l === "removeStorage")
583
583
  return () => {
584
- const d = r.getState().initialStateGlobal[t], e = tt(t), o = Y(e?.localStorage?.key) ? e?.localStorage?.key(d) : e?.localStorage?.key, s = `${f}-${t}-${o}`;
584
+ const d = r.getState().initialStateGlobal[t], e = et(t), o = Y(e?.localStorage?.key) ? e?.localStorage?.key(d) : e?.localStorage?.key, s = `${f}-${t}-${o}`;
585
585
  s && localStorage.removeItem(s);
586
586
  };
587
587
  if (l === "showValidationErrors")
@@ -591,10 +591,10 @@ function dt(t, i, h, f) {
591
591
  throw new Error("Validation key not found");
592
592
  return r.getState().getValidationErrors(d.key + "." + n.join("."));
593
593
  };
594
- if (Array.isArray(I)) {
595
- const d = () => m?.validIndices ? I.map((o, s) => ({
594
+ if (Array.isArray(v)) {
595
+ const d = () => S?.validIndices ? v.map((o, s) => ({
596
596
  item: o,
597
- originalIndex: m.validIndices[s]
597
+ originalIndex: S.validIndices[s]
598
598
  })) : r.getState().getNestedState(t, n).map((o, s) => ({
599
599
  item: o,
600
600
  originalIndex: s
@@ -604,9 +604,9 @@ function dt(t, i, h, f) {
604
604
  const e = r.getState().getSelectedIndex(t, n.join("."));
605
605
  if (e !== void 0)
606
606
  return a(
607
- I[e],
607
+ v[e],
608
608
  [...n, e.toString()],
609
- m
609
+ S
610
610
  );
611
611
  };
612
612
  if (l === "clearSelected")
@@ -621,133 +621,137 @@ function dt(t, i, h, f) {
621
621
  itemHeight: o = 50,
622
622
  overscan: s = 6,
623
623
  stickToBottom: c = !1
624
- } = e, g = Q(null), [u, T] = X({
624
+ } = e, g = Z(null), [u, T] = K({
625
625
  startIndex: 0,
626
626
  endIndex: 10
627
- }), A = Q(c), [E, _] = X(0);
628
- et(() => r.getState().subscribeToShadowState(t, () => {
629
- _((k) => k + 1);
627
+ }), w = Z(c), E = Z(!1), [M, P] = K(0);
628
+ nt(() => r.getState().subscribeToShadowState(t, () => {
629
+ P((k) => k + 1);
630
630
  }), [t]);
631
- const x = r().getNestedState(
631
+ const O = r().getNestedState(
632
632
  t,
633
633
  n
634
- ), $ = x.length, { totalHeight: F, positions: L } = ht(() => {
635
- const S = r.getState().getShadowMetadata(t, n) || [];
634
+ ), x = O.length, { totalHeight: H, positions: V } = vt(() => {
635
+ const A = r.getState().getShadowMetadata(t, n) || [];
636
636
  let k = 0;
637
- const C = [];
638
- for (let V = 0; V < $; V++) {
639
- C[V] = k;
640
- const P = S[V]?.virtualizer?.itemHeight;
641
- k += P || o;
637
+ const _ = [];
638
+ for (let C = 0; C < x; C++) {
639
+ _[C] = k;
640
+ const W = A[C]?.virtualizer?.itemHeight;
641
+ k += W || o;
642
642
  }
643
- return { totalHeight: k, positions: C };
643
+ return { totalHeight: k, positions: _ };
644
644
  }, [
645
- $,
645
+ x,
646
646
  t,
647
647
  n.join("."),
648
648
  o,
649
- E
650
- ]), M = ht(() => {
651
- const S = Math.max(0, u.startIndex), k = Math.min($, u.endIndex), C = Array.from(
652
- { length: k - S },
653
- (P, H) => S + H
654
- ), V = C.map((P) => x[P]);
655
- return a(V, n, {
656
- ...m,
657
- validIndices: C
649
+ M
650
+ ]), N = vt(() => {
651
+ const A = Math.max(0, u.startIndex), k = Math.min(x, u.endIndex), _ = Array.from(
652
+ { length: k - A },
653
+ (W, q) => A + q
654
+ ), C = _.map((W) => O[W]);
655
+ return a(C, n, {
656
+ ...S,
657
+ validIndices: _
658
658
  });
659
- }, [u.startIndex, u.endIndex, x, $]);
660
- ct(() => {
661
- const S = g.current;
662
- if (!S || !A.current || $ === 0)
659
+ }, [u.startIndex, u.endIndex, O, x]);
660
+ lt(() => {
661
+ const A = g.current;
662
+ if (!A || !w.current || x === 0)
663
663
  return;
664
664
  console.log("ALGORITHM: Starting..."), T({
665
- startIndex: Math.max(0, $ - 10 - s),
666
- endIndex: $
665
+ startIndex: Math.max(0, x - 10 - s),
666
+ endIndex: x
667
667
  }), console.log(
668
668
  "ALGORITHM: Starting LOOP to wait for measurement."
669
669
  );
670
- let C = 0;
671
- const V = setInterval(() => {
672
- C++, console.log(`LOOP ${C}: Checking last item...`);
673
- const P = $ - 1, B = (r.getState().getShadowMetadata(t, n) || [])[P]?.virtualizer?.itemHeight || 0;
674
- B > 0 ? (console.log(
675
- `%cSUCCESS: Last item height is ${B}. Scrolling now.`,
670
+ let _ = 0;
671
+ const C = setInterval(() => {
672
+ _++, console.log(`LOOP ${_}: Checking last item...`);
673
+ const W = x - 1, Q = (r.getState().getShadowMetadata(t, n) || [])[W]?.virtualizer?.itemHeight || 0;
674
+ Q > 0 ? (console.log(
675
+ `%cSUCCESS: Last item height is ${Q}. Scrolling now.`,
676
676
  "color: green; font-weight: bold;"
677
- ), clearInterval(V), S.scrollTo({
678
- top: S.scrollHeight,
677
+ ), clearInterval(C), E.current = !0, A.scrollTo({
678
+ top: A.scrollHeight,
679
679
  behavior: "smooth"
680
- })) : (console.log("...WAITING. Height is not ready."), C > 20 && (console.error(
680
+ }), setTimeout(() => {
681
+ E.current = !1;
682
+ }, 1e3)) : (console.log("...WAITING. Height is not ready."), _ > 20 && (console.error(
681
683
  "LOOP TIMEOUT: Last item was never measured. Stopping loop."
682
- ), clearInterval(V)));
684
+ ), clearInterval(C)));
683
685
  }, 100);
684
686
  return () => {
685
- console.log("ALGORITHM: Cleaning up loop."), clearInterval(V);
687
+ console.log("ALGORITHM: Cleaning up loop."), clearInterval(C);
686
688
  };
687
- }, [$, ...e.dependencies ?? []]), et(() => {
688
- const S = g.current;
689
- if (!S) return;
689
+ }, [x, H, ...e.dependencies ?? []]), nt(() => {
690
+ const A = g.current;
691
+ if (!A) return;
690
692
  const k = () => {
691
- const { scrollTop: V, clientHeight: P } = S;
692
- let H = 0, B = $ - 1;
693
- for (; H <= B; ) {
694
- const ft = Math.floor((H + B) / 2);
695
- L[ft] < V ? H = ft + 1 : B = ft - 1;
693
+ const { scrollTop: C, clientHeight: W } = A;
694
+ let q = 0, Q = x - 1;
695
+ for (; q <= Q; ) {
696
+ const St = Math.floor((q + Q) / 2);
697
+ V[St] < C ? q = St + 1 : Q = St - 1;
696
698
  }
697
- const pt = Math.max(0, B - s);
698
- let st = pt;
699
- const xt = V + P;
700
- for (; st < $ && L[st] < xt; )
701
- st++;
699
+ const wt = Math.max(0, Q - s);
700
+ let it = wt;
701
+ const Vt = C + W;
702
+ for (; it < x && V[it] < Vt; )
703
+ it++;
702
704
  T({
703
- startIndex: pt,
704
- endIndex: Math.min($, st + s)
705
+ startIndex: wt,
706
+ endIndex: Math.min(x, it + s)
705
707
  });
706
- }, C = () => {
707
- S.scrollHeight - S.scrollTop - S.clientHeight < 1 || (A.current = !1, console.log("USER ACTION: Scroll lock DISABLED.")), k();
708
+ }, _ = () => {
709
+ if (E.current)
710
+ return;
711
+ A.scrollHeight - A.scrollTop - A.clientHeight < 1 || (w.current = !1, console.log("USER ACTION: Scroll lock DISABLED.")), k();
708
712
  };
709
- return S.addEventListener("scroll", C, {
713
+ return A.addEventListener("scroll", _, {
710
714
  passive: !0
711
- }), k(), () => S.removeEventListener("scroll", C);
712
- }, [$, L]);
713
- const N = wt(
714
- (S = "smooth") => {
715
- g.current && (A.current = !0, console.log("USER ACTION: Scroll lock ENABLED."), g.current.scrollTo({
715
+ }), k(), () => A.removeEventListener("scroll", _);
716
+ }, [x, V]);
717
+ const U = At(
718
+ (A = "smooth") => {
719
+ g.current && (w.current = !0, console.log("USER ACTION: Scroll lock ENABLED."), g.current.scrollTo({
716
720
  top: g.current.scrollHeight,
717
- behavior: S
721
+ behavior: A
718
722
  }));
719
723
  },
720
724
  []
721
- ), R = wt(
722
- (S, k = "smooth") => {
723
- g.current && L[S] !== void 0 && (A.current = !1, console.log("USER ACTION: Scroll lock DISABLED."), g.current.scrollTo({
724
- top: L[S],
725
+ ), D = At(
726
+ (A, k = "smooth") => {
727
+ g.current && V[A] !== void 0 && (w.current = !1, console.log("USER ACTION: Scroll lock DISABLED."), g.current.scrollTo({
728
+ top: V[A],
725
729
  behavior: k
726
730
  }));
727
731
  },
728
- [L]
729
- ), D = {
732
+ [V]
733
+ ), $ = {
730
734
  outer: {
731
735
  ref: g,
732
736
  style: { overflowY: "auto", height: "100%" }
733
737
  },
734
738
  inner: {
735
739
  style: {
736
- height: `${F}px`,
740
+ height: `${H}px`,
737
741
  position: "relative"
738
742
  }
739
743
  },
740
744
  list: {
741
745
  style: {
742
- transform: `translateY(${L[u.startIndex] || 0}px)`
746
+ transform: `translateY(${V[u.startIndex] || 0}px)`
743
747
  }
744
748
  }
745
749
  };
746
750
  return {
747
- virtualState: M,
748
- virtualizerProps: D,
749
- scrollToBottom: N,
750
- scrollToIndex: R
751
+ virtualState: N,
752
+ virtualizerProps: $,
753
+ scrollToBottom: U,
754
+ scrollToIndex: D
751
755
  };
752
756
  };
753
757
  if (l === "stateSort")
@@ -755,7 +759,7 @@ function dt(t, i, h, f) {
755
759
  const s = [...d()].sort(
756
760
  (u, T) => e(u.item, T.item)
757
761
  ), c = s.map(({ item: u }) => u), g = {
758
- ...m,
762
+ ...S,
759
763
  validIndices: s.map(
760
764
  ({ originalIndex: u }) => u
761
765
  )
@@ -767,7 +771,7 @@ function dt(t, i, h, f) {
767
771
  const s = d().filter(
768
772
  ({ item: u }, T) => e(u, T)
769
773
  ), c = s.map(({ item: u }) => u), g = {
770
- ...m,
774
+ ...S,
771
775
  validIndices: s.map(
772
776
  ({ originalIndex: u }) => u
773
777
  )
@@ -777,23 +781,23 @@ function dt(t, i, h, f) {
777
781
  if (l === "stateMap")
778
782
  return (e) => {
779
783
  const o = r.getState().getNestedState(t, n);
780
- return Array.isArray(o) ? (m?.validIndices || Array.from({ length: o.length }, (c, g) => g)).map((c, g) => {
781
- const u = o[c], T = [...n, c.toString()], A = a(u, T, m);
782
- return e(u, A, {
784
+ return Array.isArray(o) ? (S?.validIndices || Array.from({ length: o.length }, (c, g) => g)).map((c, g) => {
785
+ const u = o[c], T = [...n, c.toString()], w = a(u, T, S);
786
+ return e(u, w, {
783
787
  register: () => {
784
- const [, _] = X({}), x = `${h}-${n.join(".")}-${c}`;
785
- ct(() => {
786
- const $ = `${t}////${x}`, F = r.getState().stateComponents.get(t) || {
788
+ const [, M] = K({}), P = `${m}-${n.join(".")}-${c}`;
789
+ lt(() => {
790
+ const O = `${t}////${P}`, x = r.getState().stateComponents.get(t) || {
787
791
  components: /* @__PURE__ */ new Map()
788
792
  };
789
- return F.components.set($, {
790
- forceUpdate: () => _({}),
793
+ return x.components.set(O, {
794
+ forceUpdate: () => M({}),
791
795
  paths: /* @__PURE__ */ new Set([T.join(".")])
792
- }), r.getState().stateComponents.set(t, F), () => {
793
- const L = r.getState().stateComponents.get(t);
794
- L && L.components.delete($);
796
+ }), r.getState().stateComponents.set(t, x), () => {
797
+ const H = r.getState().stateComponents.get(t);
798
+ H && H.components.delete(O);
795
799
  };
796
- }, [t, x]);
800
+ }, [t, P]);
797
801
  },
798
802
  index: g,
799
803
  originalIndex: c
@@ -804,20 +808,20 @@ function dt(t, i, h, f) {
804
808
  ), null);
805
809
  };
806
810
  if (l === "stateMapNoRender")
807
- return (e) => I.map((s, c) => {
811
+ return (e) => v.map((s, c) => {
808
812
  let g;
809
- m?.validIndices && m.validIndices[c] !== void 0 ? g = m.validIndices[c] : g = c;
810
- const u = [...n, g.toString()], T = a(s, u, m);
813
+ S?.validIndices && S.validIndices[c] !== void 0 ? g = S.validIndices[c] : g = c;
814
+ const u = [...n, g.toString()], T = a(s, u, S);
811
815
  return e(
812
816
  s,
813
817
  T,
814
818
  c,
815
- I,
816
- a(I, n, m)
819
+ v,
820
+ a(v, n, S)
817
821
  );
818
822
  });
819
823
  if (l === "$stateMap")
820
- return (e) => ot(qt, {
824
+ return (e) => at(Jt, {
821
825
  proxy: {
822
826
  _stateKey: t,
823
827
  _path: n,
@@ -829,19 +833,19 @@ function dt(t, i, h, f) {
829
833
  if (l === "stateList")
830
834
  return (e) => {
831
835
  const o = r.getState().getNestedState(t, n);
832
- return Array.isArray(o) ? (m?.validIndices || Array.from({ length: o.length }, (c, g) => g)).map((c, g) => {
833
- const u = o[c], T = [...n, c.toString()], A = a(u, T, m), E = `${h}-${n.join(".")}-${c}`;
834
- return ot(Yt, {
836
+ return Array.isArray(o) ? (S?.validIndices || Array.from({ length: o.length }, (c, g) => g)).map((c, g) => {
837
+ const u = o[c], T = [...n, c.toString()], w = a(u, T, S), E = `${m}-${n.join(".")}-${c}`;
838
+ return at(Zt, {
835
839
  key: c,
836
840
  stateKey: t,
837
841
  itemComponentId: E,
838
842
  itemPath: T,
839
843
  children: e(
840
844
  u,
841
- A,
845
+ w,
842
846
  g,
843
847
  o,
844
- a(o, n, m)
848
+ a(o, n, S)
845
849
  )
846
850
  });
847
851
  }) : (console.warn(
@@ -850,20 +854,20 @@ function dt(t, i, h, f) {
850
854
  };
851
855
  if (l === "stateFlattenOn")
852
856
  return (e) => {
853
- const o = I;
854
- y.clear(), b++;
857
+ const o = v;
858
+ I.clear(), b++;
855
859
  const s = o.flatMap(
856
860
  (c) => c[e] ?? []
857
861
  );
858
862
  return a(
859
863
  s,
860
864
  [...n, "[*]", e],
861
- m
865
+ S
862
866
  );
863
867
  };
864
868
  if (l === "index")
865
869
  return (e) => {
866
- const o = I[e];
870
+ const o = v[e];
867
871
  return a(o, [...n, e.toString()]);
868
872
  };
869
873
  if (l === "last")
@@ -874,7 +878,7 @@ function dt(t, i, h, f) {
874
878
  return a(s, c);
875
879
  };
876
880
  if (l === "insert")
877
- return (e) => (w(n), St(i, e, n, t), a(
881
+ return (e) => (p(n), mt(i, e, n, t), a(
878
882
  r.getState().getNestedState(t, n),
879
883
  n
880
884
  ));
@@ -882,41 +886,41 @@ function dt(t, i, h, f) {
882
886
  return (e, o, s) => {
883
887
  const c = r.getState().getNestedState(t, n), g = Y(e) ? e(c) : e;
884
888
  let u = null;
885
- if (!c.some((A) => {
889
+ if (!c.some((w) => {
886
890
  if (o) {
887
- const _ = o.every(
888
- (x) => z(A[x], g[x])
891
+ const M = o.every(
892
+ (P) => B(w[P], g[P])
889
893
  );
890
- return _ && (u = A), _;
894
+ return M && (u = w), M;
891
895
  }
892
- const E = z(A, g);
893
- return E && (u = A), E;
896
+ const E = B(w, g);
897
+ return E && (u = w), E;
894
898
  }))
895
- w(n), St(i, g, n, t);
899
+ p(n), mt(i, g, n, t);
896
900
  else if (s && u) {
897
- const A = s(u), E = c.map(
898
- (_) => z(_, u) ? A : _
901
+ const w = s(u), E = c.map(
902
+ (M) => B(M, u) ? w : M
899
903
  );
900
- w(n), rt(i, E, n);
904
+ p(n), ot(i, E, n);
901
905
  }
902
906
  };
903
907
  if (l === "cut")
904
908
  return (e, o) => {
905
909
  if (!o?.waitForSync)
906
- return w(n), it(i, n, t, e), a(
910
+ return p(n), ct(i, n, t, e), a(
907
911
  r.getState().getNestedState(t, n),
908
912
  n
909
913
  );
910
914
  };
911
915
  if (l === "cutByValue")
912
916
  return (e) => {
913
- for (let o = 0; o < I.length; o++)
914
- I[o] === e && it(i, n, t, o);
917
+ for (let o = 0; o < v.length; o++)
918
+ v[o] === e && ct(i, n, t, o);
915
919
  };
916
920
  if (l === "toggleByValue")
917
921
  return (e) => {
918
- const o = I.findIndex((s) => s === e);
919
- o > -1 ? it(i, n, t, o) : St(i, e, n, t);
922
+ const o = v.findIndex((s) => s === e);
923
+ o > -1 ? ct(i, n, t, o) : mt(i, e, n, t);
920
924
  };
921
925
  if (l === "stateFind")
922
926
  return (e) => {
@@ -925,7 +929,7 @@ function dt(t, i, h, f) {
925
929
  );
926
930
  if (!s) return;
927
931
  const c = [...n, s.originalIndex.toString()];
928
- return a(s.item, c, m);
932
+ return a(s.item, c, S);
929
933
  };
930
934
  if (l === "findWith")
931
935
  return (e, o) => {
@@ -934,36 +938,36 @@ function dt(t, i, h, f) {
934
938
  );
935
939
  if (!c) return;
936
940
  const g = [...n, c.originalIndex.toString()];
937
- return a(c.item, g, m);
941
+ return a(c.item, g, S);
938
942
  };
939
943
  }
940
- const Z = n[n.length - 1];
941
- if (!isNaN(Number(Z))) {
944
+ const X = n[n.length - 1];
945
+ if (!isNaN(Number(X))) {
942
946
  const d = n.slice(0, -1), e = r.getState().getNestedState(t, d);
943
947
  if (Array.isArray(e) && l === "cut")
944
- return () => it(
948
+ return () => ct(
945
949
  i,
946
950
  d,
947
951
  t,
948
- Number(Z)
952
+ Number(X)
949
953
  );
950
954
  }
951
955
  if (l === "get")
952
956
  return () => {
953
- if (m?.validIndices && Array.isArray(I)) {
957
+ if (S?.validIndices && Array.isArray(v)) {
954
958
  const d = r.getState().getNestedState(t, n);
955
- return m.validIndices.map((e) => d[e]);
959
+ return S.validIndices.map((e) => d[e]);
956
960
  }
957
961
  return r.getState().getNestedState(t, n);
958
962
  };
959
963
  if (l === "$derive")
960
- return (d) => kt({
964
+ return (d) => Ct({
961
965
  _stateKey: t,
962
966
  _path: n,
963
967
  _effect: d.toString()
964
968
  });
965
969
  if (l === "$get")
966
- return () => kt({
970
+ return () => Ct({
967
971
  _stateKey: t,
968
972
  _path: n
969
973
  });
@@ -972,7 +976,7 @@ function dt(t, i, h, f) {
972
976
  return r.getState().getSyncInfo(d);
973
977
  }
974
978
  if (l == "getLocalStorage")
975
- return (d) => ut(f + "-" + t + "-" + d);
979
+ return (d) => gt(f + "-" + t + "-" + d);
976
980
  if (l === "_selected") {
977
981
  const d = n.slice(0, -1), e = d.join("."), o = r.getState().getNestedState(t, d);
978
982
  return Array.isArray(o) ? Number(n[n.length - 1]) === r.getState().getSelectedIndex(t, e) : void 0;
@@ -982,7 +986,7 @@ function dt(t, i, h, f) {
982
986
  const e = n.slice(0, -1), o = Number(n[n.length - 1]), s = e.join(".");
983
987
  d ? r.getState().setSelectedIndex(t, s, o) : r.getState().setSelectedIndex(t, s, void 0);
984
988
  const c = r.getState().getNestedState(t, [...e]);
985
- rt(i, c, e), w(e);
989
+ ot(i, c, e), p(e);
986
990
  };
987
991
  if (l === "toggleSelected")
988
992
  return () => {
@@ -993,73 +997,73 @@ function dt(t, i, h, f) {
993
997
  s === e ? void 0 : e
994
998
  );
995
999
  const c = r.getState().getNestedState(t, [...d]);
996
- rt(i, c, d), w(d);
1000
+ ot(i, c, d), p(d);
997
1001
  };
998
1002
  if (n.length == 0) {
999
1003
  if (l === "applyJsonPatch")
1000
1004
  return (d) => {
1001
- const e = r.getState().cogsStateStore[t], s = jt(e, d).newDocument;
1002
- Nt(
1005
+ const e = r.getState().cogsStateStore[t], s = Lt(e, d).newDocument;
1006
+ xt(
1003
1007
  t,
1004
1008
  r.getState().initialStateGlobal[t],
1005
1009
  s,
1006
1010
  i,
1007
- h,
1011
+ m,
1008
1012
  f
1009
1013
  );
1010
1014
  const c = r.getState().stateComponents.get(t);
1011
1015
  if (c) {
1012
- const g = vt(e, s), u = new Set(g);
1016
+ const g = It(e, s), u = new Set(g);
1013
1017
  for (const [
1014
1018
  T,
1015
- A
1019
+ w
1016
1020
  ] of c.components.entries()) {
1017
1021
  let E = !1;
1018
- const _ = Array.isArray(A.reactiveType) ? A.reactiveType : [A.reactiveType || "component"];
1019
- if (!_.includes("none")) {
1020
- if (_.includes("all")) {
1021
- A.forceUpdate();
1022
+ const M = Array.isArray(w.reactiveType) ? w.reactiveType : [w.reactiveType || "component"];
1023
+ if (!M.includes("none")) {
1024
+ if (M.includes("all")) {
1025
+ w.forceUpdate();
1022
1026
  continue;
1023
1027
  }
1024
- if (_.includes("component") && (A.paths.has("") && (E = !0), !E))
1025
- for (const x of u) {
1026
- if (A.paths.has(x)) {
1028
+ if (M.includes("component") && (w.paths.has("") && (E = !0), !E))
1029
+ for (const P of u) {
1030
+ if (w.paths.has(P)) {
1027
1031
  E = !0;
1028
1032
  break;
1029
1033
  }
1030
- let $ = x.lastIndexOf(".");
1031
- for (; $ !== -1; ) {
1032
- const F = x.substring(0, $);
1033
- if (A.paths.has(F)) {
1034
+ let O = P.lastIndexOf(".");
1035
+ for (; O !== -1; ) {
1036
+ const x = P.substring(0, O);
1037
+ if (w.paths.has(x)) {
1034
1038
  E = !0;
1035
1039
  break;
1036
1040
  }
1037
- const L = x.substring(
1038
- $ + 1
1041
+ const H = P.substring(
1042
+ O + 1
1039
1043
  );
1040
- if (!isNaN(Number(L))) {
1041
- const M = F.lastIndexOf(".");
1042
- if (M !== -1) {
1043
- const N = F.substring(
1044
+ if (!isNaN(Number(H))) {
1045
+ const V = x.lastIndexOf(".");
1046
+ if (V !== -1) {
1047
+ const N = x.substring(
1044
1048
  0,
1045
- M
1049
+ V
1046
1050
  );
1047
- if (A.paths.has(N)) {
1051
+ if (w.paths.has(N)) {
1048
1052
  E = !0;
1049
1053
  break;
1050
1054
  }
1051
1055
  }
1052
1056
  }
1053
- $ = F.lastIndexOf(".");
1057
+ O = x.lastIndexOf(".");
1054
1058
  }
1055
1059
  if (E) break;
1056
1060
  }
1057
- if (!E && _.includes("deps") && A.depsFunction) {
1058
- const x = A.depsFunction(s);
1059
- let $ = !1;
1060
- typeof x == "boolean" ? x && ($ = !0) : z(A.deps, x) || (A.deps = x, $ = !0), $ && (E = !0);
1061
+ if (!E && M.includes("deps") && w.depsFunction) {
1062
+ const P = w.depsFunction(s);
1063
+ let O = !1;
1064
+ typeof P == "boolean" ? P && (O = !0) : B(w.deps, P) || (w.deps = P, O = !0), O && (E = !0);
1061
1065
  }
1062
- E && A.forceUpdate();
1066
+ E && w.forceUpdate();
1063
1067
  }
1064
1068
  }
1065
1069
  }
@@ -1080,18 +1084,18 @@ function dt(t, i, h, f) {
1080
1084
  });
1081
1085
  const c = d.zodSchema.safeParse(o);
1082
1086
  return c.success ? !0 : (c.error.errors.forEach((u) => {
1083
- const T = u.path, A = u.message, E = [d.key, ...T].join(".");
1084
- e(E, A);
1085
- }), gt(t), !1);
1087
+ const T = u.path, w = u.message, E = [d.key, ...T].join(".");
1088
+ e(E, w);
1089
+ }), ft(t), !1);
1086
1090
  } catch (s) {
1087
1091
  return console.error("Zod schema validation failed", s), !1;
1088
1092
  }
1089
1093
  };
1090
- if (l === "_componentId") return h;
1094
+ if (l === "_componentId") return m;
1091
1095
  if (l === "getComponents")
1092
1096
  return () => r().stateComponents.get(t);
1093
1097
  if (l === "getAllFormRefs")
1094
- return () => At.getState().getFormRefsByStateKey(t);
1098
+ return () => Tt.getState().getFormRefsByStateKey(t);
1095
1099
  if (l === "_initialState")
1096
1100
  return r.getState().initialStateGlobal[t];
1097
1101
  if (l === "_serverState")
@@ -1099,48 +1103,48 @@ function dt(t, i, h, f) {
1099
1103
  if (l === "_isLoading")
1100
1104
  return r.getState().isLoadingGlobal[t];
1101
1105
  if (l === "revertToInitialState")
1102
- return p.revertToInitialState;
1103
- if (l === "updateInitialState") return p.updateInitialState;
1104
- if (l === "removeValidation") return p.removeValidation;
1106
+ return y.revertToInitialState;
1107
+ if (l === "updateInitialState") return y.updateInitialState;
1108
+ if (l === "removeValidation") return y.removeValidation;
1105
1109
  }
1106
1110
  if (l === "getFormRef")
1107
- return () => At.getState().getFormRef(t + "." + n.join("."));
1111
+ return () => Tt.getState().getFormRef(t + "." + n.join("."));
1108
1112
  if (l === "validationWrapper")
1109
1113
  return ({
1110
1114
  children: d,
1111
1115
  hideMessage: e
1112
- }) => /* @__PURE__ */ mt(
1113
- Ot,
1116
+ }) => /* @__PURE__ */ ht(
1117
+ Rt,
1114
1118
  {
1115
1119
  formOpts: e ? { validation: { message: "" } } : void 0,
1116
1120
  path: n,
1117
1121
  validationKey: r.getState().getInitialOptions(t)?.validation?.key || "",
1118
1122
  stateKey: t,
1119
- validIndices: m?.validIndices,
1123
+ validIndices: S?.validIndices,
1120
1124
  children: d
1121
1125
  }
1122
1126
  );
1123
1127
  if (l === "_stateKey") return t;
1124
1128
  if (l === "_path") return n;
1125
- if (l === "_isServerSynced") return p._isServerSynced;
1129
+ if (l === "_isServerSynced") return y._isServerSynced;
1126
1130
  if (l === "update")
1127
1131
  return (d, e) => {
1128
1132
  if (e?.debounce)
1129
- Mt(() => {
1130
- rt(i, d, n, "");
1133
+ Ot(() => {
1134
+ ot(i, d, n, "");
1131
1135
  const o = r.getState().getNestedState(t, n);
1132
1136
  e?.afterUpdate && e.afterUpdate(o);
1133
1137
  }, e.debounce);
1134
1138
  else {
1135
- rt(i, d, n, "");
1139
+ ot(i, d, n, "");
1136
1140
  const o = r.getState().getNestedState(t, n);
1137
1141
  e?.afterUpdate && e.afterUpdate(o);
1138
1142
  }
1139
- w(n);
1143
+ p(n);
1140
1144
  };
1141
1145
  if (l === "formElement")
1142
- return (d, e) => /* @__PURE__ */ mt(
1143
- Rt,
1146
+ return (d, e) => /* @__PURE__ */ ht(
1147
+ Ut,
1144
1148
  {
1145
1149
  setState: i,
1146
1150
  stateKey: t,
@@ -1149,120 +1153,120 @@ function dt(t, i, h, f) {
1149
1153
  formOpts: e
1150
1154
  }
1151
1155
  );
1152
- const O = [...n, l], nt = r.getState().getNestedState(t, O);
1153
- return a(nt, O, m);
1156
+ const R = [...n, l], rt = r.getState().getNestedState(t, R);
1157
+ return a(rt, R, S);
1154
1158
  }
1155
- }, W = new Proxy(U, j);
1156
- return y.set(G, {
1157
- proxy: W,
1159
+ }, G = new Proxy(j, L);
1160
+ return I.set(F, {
1161
+ proxy: G,
1158
1162
  stateVersion: b
1159
- }), W;
1163
+ }), G;
1160
1164
  }
1161
1165
  return a(
1162
1166
  r.getState().getNestedState(t, [])
1163
1167
  );
1164
1168
  }
1165
- function kt(t) {
1166
- return ot(Jt, { proxy: t });
1169
+ function Ct(t) {
1170
+ return at(Yt, { proxy: t });
1167
1171
  }
1168
- function qt({
1172
+ function Jt({
1169
1173
  proxy: t,
1170
1174
  rebuildStateShape: i
1171
1175
  }) {
1172
- const h = r().getNestedState(t._stateKey, t._path);
1173
- return Array.isArray(h) ? i(
1174
- h,
1176
+ const m = r().getNestedState(t._stateKey, t._path);
1177
+ return Array.isArray(m) ? i(
1178
+ m,
1175
1179
  t._path
1176
1180
  ).stateMapNoRender(
1177
- (y, b, w, p, a) => t._mapFn(y, b, w, p, a)
1181
+ (I, b, p, y, a) => t._mapFn(I, b, p, y, a)
1178
1182
  ) : null;
1179
1183
  }
1180
- function Jt({
1184
+ function Yt({
1181
1185
  proxy: t
1182
1186
  }) {
1183
- const i = Q(null), h = `${t._stateKey}-${t._path.join(".")}`;
1184
- return et(() => {
1187
+ const i = Z(null), m = `${t._stateKey}-${t._path.join(".")}`;
1188
+ return nt(() => {
1185
1189
  const f = i.current;
1186
1190
  if (!f || !f.parentElement) return;
1187
- const y = f.parentElement, w = Array.from(y.childNodes).indexOf(f);
1188
- let p = y.getAttribute("data-parent-id");
1189
- p || (p = `parent-${crypto.randomUUID()}`, y.setAttribute("data-parent-id", p));
1190
- const I = {
1191
+ const I = f.parentElement, p = Array.from(I.childNodes).indexOf(f);
1192
+ let y = I.getAttribute("data-parent-id");
1193
+ y || (y = `parent-${crypto.randomUUID()}`, I.setAttribute("data-parent-id", y));
1194
+ const v = {
1191
1195
  instanceId: `instance-${crypto.randomUUID()}`,
1192
- parentId: p,
1193
- position: w,
1196
+ parentId: y,
1197
+ position: p,
1194
1198
  effect: t._effect
1195
1199
  };
1196
- r.getState().addSignalElement(h, I);
1200
+ r.getState().addSignalElement(m, v);
1197
1201
  const n = r.getState().getNestedState(t._stateKey, t._path);
1198
- let m;
1202
+ let S;
1199
1203
  if (t._effect)
1200
1204
  try {
1201
- m = new Function(
1205
+ S = new Function(
1202
1206
  "state",
1203
1207
  `return (${t._effect})(state)`
1204
1208
  )(n);
1205
- } catch (U) {
1206
- console.error("Error evaluating effect function during mount:", U), m = n;
1209
+ } catch (j) {
1210
+ console.error("Error evaluating effect function during mount:", j), S = n;
1207
1211
  }
1208
1212
  else
1209
- m = n;
1210
- m !== null && typeof m == "object" && (m = JSON.stringify(m));
1211
- const G = document.createTextNode(String(m));
1212
- f.replaceWith(G);
1213
- }, [t._stateKey, t._path.join("."), t._effect]), ot("span", {
1213
+ S = n;
1214
+ S !== null && typeof S == "object" && (S = JSON.stringify(S));
1215
+ const F = document.createTextNode(String(S));
1216
+ f.replaceWith(F);
1217
+ }, [t._stateKey, t._path.join("."), t._effect]), at("span", {
1214
1218
  ref: i,
1215
1219
  style: { display: "none" },
1216
- "data-signal-id": h
1220
+ "data-signal-id": m
1217
1221
  });
1218
1222
  }
1219
- function de(t) {
1220
- const i = Vt(
1221
- (h) => {
1223
+ function ue(t) {
1224
+ const i = Pt(
1225
+ (m) => {
1222
1226
  const f = r.getState().stateComponents.get(t._stateKey) || {
1223
1227
  components: /* @__PURE__ */ new Map()
1224
1228
  };
1225
1229
  return f.components.set(t._stateKey, {
1226
- forceUpdate: h,
1230
+ forceUpdate: m,
1227
1231
  paths: /* @__PURE__ */ new Set([t._path.join(".")])
1228
1232
  }), () => f.components.delete(t._stateKey);
1229
1233
  },
1230
1234
  () => r.getState().getNestedState(t._stateKey, t._path)
1231
1235
  );
1232
- return ot("text", {}, String(i));
1236
+ return at("text", {}, String(i));
1233
1237
  }
1234
- function Yt({
1238
+ function Zt({
1235
1239
  stateKey: t,
1236
1240
  itemComponentId: i,
1237
- itemPath: h,
1241
+ itemPath: m,
1238
1242
  children: f
1239
1243
  }) {
1240
- const [, y] = X({}), [b, w] = Lt(), p = Q(null);
1241
- return et(() => {
1242
- w.height > 0 && w.height !== p.current && (p.current = w.height, r.getState().setShadowMetadata(t, h, {
1244
+ const [, I] = K({}), [b, p] = Dt(), y = Z(null);
1245
+ return nt(() => {
1246
+ p.height > 0 && p.height !== y.current && (y.current = p.height, r.getState().setShadowMetadata(t, m, {
1243
1247
  virtualizer: {
1244
- itemHeight: w.height
1248
+ itemHeight: p.height
1245
1249
  }
1246
1250
  }));
1247
- }, [w.height, t, h]), ct(() => {
1248
- const a = `${t}////${i}`, I = r.getState().stateComponents.get(t) || {
1251
+ }, [p.height, t, m]), lt(() => {
1252
+ const a = `${t}////${i}`, v = r.getState().stateComponents.get(t) || {
1249
1253
  components: /* @__PURE__ */ new Map()
1250
1254
  };
1251
- return I.components.set(a, {
1252
- forceUpdate: () => y({}),
1253
- paths: /* @__PURE__ */ new Set([h.join(".")])
1254
- }), r.getState().stateComponents.set(t, I), () => {
1255
+ return v.components.set(a, {
1256
+ forceUpdate: () => I({}),
1257
+ paths: /* @__PURE__ */ new Set([m.join(".")])
1258
+ }), r.getState().stateComponents.set(t, v), () => {
1255
1259
  const n = r.getState().stateComponents.get(t);
1256
1260
  n && n.components.delete(a);
1257
1261
  };
1258
- }, [t, i, h.join(".")]), /* @__PURE__ */ mt("div", { ref: b, children: f });
1262
+ }, [t, i, m.join(".")]), /* @__PURE__ */ ht("div", { ref: b, children: f });
1259
1263
  }
1260
1264
  export {
1261
- kt as $cogsSignal,
1262
- de as $cogsSignalStore,
1263
- ie as addStateOptions,
1264
- ce as createCogsState,
1265
- le as notifyComponent,
1266
- zt as useCogsStateFn
1265
+ Ct as $cogsSignal,
1266
+ ue as $cogsSignalStore,
1267
+ ce as addStateOptions,
1268
+ le as createCogsState,
1269
+ de as notifyComponent,
1270
+ qt as useCogsStateFn
1267
1271
  };
1268
1272
  //# sourceMappingURL=CogsState.jsx.map