@nice2dev/erp-adapter 0.1.0 → 1.0.3

package/dist/index.mjs

@@ -1,27 +1,28 @@
-class y {
+import { useState as O, useRef as ae, useCallback as m, useEffect as W, useMemo as de } from "react";
+class Ve {
   constructor(e) {
     this.cfg = typeof e == "string" ? { baseUrl: e } : e;
   }
-  async request(e, a) {
-    const t = this.cfg.fetch ?? globalThis.fetch, l = {
+  async request(e, t) {
+    const n = this.cfg.fetch ?? globalThis.fetch, a = {
       "Content-Type": "application/json",
       ...this.cfg.headers
     };
     if (this.cfg.tokenFactory) {
-      const r = await this.cfg.tokenFactory();
-      l.Authorization = `Bearer ${r}`;
+      const s = await this.cfg.tokenFactory();
+      a.Authorization = `Bearer ${s}`;
     }
-    const o = await t(`${this.cfg.baseUrl}${e}`, { ...a, headers: { ...l, ...a == null ? void 0 : a.headers } });
-    if (!o.ok) throw new Error(`ERP request failed: ${o.status} ${o.statusText}`);
-    return o.json();
+    const r = await n(`${this.cfg.baseUrl}${e}`, { ...t, headers: { ...a, ...t == null ? void 0 : t.headers } });
+    if (!r.ok) throw new Error(`ERP request failed: ${r.status} ${r.statusText}`);
+    return r.json();
   }
   /** Load paged/filtered/sorted data. */
   async load(e) {
-    var l, o;
-    const a = new URLSearchParams();
-    (e == null ? void 0 : e.skip) != null && a.set("skip", String(e.skip)), (e == null ? void 0 : e.take) != null && a.set("take", String(e.take)), e != null && e.search && a.set("search", e.search), (l = e == null ? void 0 : e.sort) != null && l.length && a.set("sort", JSON.stringify(e.sort)), (o = e == null ? void 0 : e.filters) != null && o.length && a.set("filters", JSON.stringify(e.filters));
-    const t = a.toString();
-    return this.request(t ? `?${t}` : "");
+    var a, r;
+    const t = new URLSearchParams();
+    (e == null ? void 0 : e.skip) != null && t.set("skip", String(e.skip)), (e == null ? void 0 : e.take) != null && t.set("take", String(e.take)), e != null && e.search && t.set("search", e.search), (a = e == null ? void 0 : e.sort) != null && a.length && t.set("sort", JSON.stringify(e.sort)), (r = e == null ? void 0 : e.filters) != null && r.length && t.set("filters", JSON.stringify(e.filters));
+    const n = t.toString();
+    return this.request(n ? `?${n}` : "");
   }
   /** Get single entity by id. */
   async getById(e) {
@@ -32,8 +33,8 @@ class y {
     return this.request("", { method: "POST", body: JSON.stringify(e) });
   }
   /** Update entity. */
-  async update(e, a) {
-    return this.request(`/${e}`, { method: "PUT", body: JSON.stringify(a) });
+  async update(e, t) {
+    return this.request(`/${e}`, { method: "PUT", body: JSON.stringify(t) });
   }
   /** Delete entity. */
   async remove(e) {
@@ -43,40 +44,792 @@ class y {
   async removeBatch(e) {
     return this.request("/batch-delete", { method: "POST", body: JSON.stringify({ ids: e }) });
   }
+  /** Batch create — send multiple items in a single request. */
+  async createBatch(e) {
+    return this.request("/batch", { method: "POST", body: JSON.stringify({ items: e }) });
+  }
+  /** Batch update — send multiple items with ids in a single request. */
+  async updateBatch(e) {
+    return this.request("/batch", { method: "PUT", body: JSON.stringify({ items: e }) });
+  }
+  /** Partial update (PATCH) a single entity. */
+  async patch(e, t) {
+    return this.request(`/${e}`, { method: "PATCH", body: JSON.stringify(t) });
+  }
 }
-async function g(s) {
+async function Ce(i) {
   const e = await import("@microsoft/signalr");
-  let a = "disconnected";
-  const t = /* @__PURE__ */ new Set(), l = (n) => {
-    a = n, t.forEach((u) => u(n));
-  }, r = new e.HubConnectionBuilder().withUrl(s.hubUrl, {
-    accessTokenFactory: s.accessTokenFactory ? () => s.accessTokenFactory() : void 0
+  let t = "disconnected";
+  const n = /* @__PURE__ */ new Set(), a = (u) => {
+    t = u, n.forEach((f) => f(u));
+  }, s = new e.HubConnectionBuilder().withUrl(i.hubUrl, {
+    accessTokenFactory: i.accessTokenFactory ? () => i.accessTokenFactory() : void 0
   }).withAutomaticReconnect().build();
-  return r.onreconnecting(() => l("reconnecting")), r.onreconnected(() => l("connected")), r.onclose(() => l("disconnected")), {
+  return s.onreconnecting(() => a("reconnecting")), s.onreconnected(() => a("connected")), s.onclose(() => a("disconnected")), {
     get status() {
-      return a;
+      return t;
     },
     async start() {
-      l("connecting"), await r.start(), l("connected");
+      a("connecting"), await s.start(), a("connected");
     },
     async stop() {
-      await r.stop(), l("disconnected");
+      await s.stop(), a("disconnected");
+    },
+    on(u, f) {
+      s.on(u, f);
+    },
+    off(u, f) {
+      s.off(u, f);
+    },
+    invoke(u, ...f) {
+      return s.invoke(u, ...f);
+    },
+    onStatusChange(u) {
+      return n.add(u), () => n.delete(u);
+    }
+  };
+}
+function he(i) {
+  const {
+    adapter: e,
+    entityName: t,
+    keyField: n,
+    initialData: a = [],
+    onBeforeChange: r,
+    onAfterChange: s,
+    onConflict: o,
+    subscribeMethod: u = "SubscribeToEntity",
+    unsubscribeMethod: f = "UnsubscribeFromEntity",
+    changeEventName: b = "EntityChanged",
+    flashChanges: y = !0,
+    flashDuration: V = 500,
+    optimisticUpdates: C = !0
+  } = i, [q, L] = O(a), [Q, G] = O(e.status), [X, U] = O(/* @__PURE__ */ new Set()), [H, R] = O(/* @__PURE__ */ new Set()), [_, Z] = O(null), J = ae(/* @__PURE__ */ new Map()), I = ae(/* @__PURE__ */ new Map()), Y = m(
+    (d, v) => {
+      const { operation: E, key: S, data: g, changes: N } = v;
+      switch (E) {
+        case "insert":
+          return !g || d.some((A) => A[n] === S) ? d : [...d, g];
+        case "update":
+          return d.map((A) => {
+            if (A[n] !== S) return A;
+            const K = J.current.get(S);
+            if (K && o) {
+              const te = o(
+                { ...A, ...K.changes },
+                g ?? { ...A, ...N },
+                v
+              );
+              return te === "local" ? { ...A, ...K.changes } : te === "remote" ? (J.current.delete(S), g ?? { ...A, ...N }) : te === "merge" ? { ...A, ...N, ...K.changes } : te;
+            }
+            return g || { ...A, ...N };
+          });
+        case "delete":
+          return d.filter((A) => A[n] !== S);
+        default:
+          return d;
+      }
+    },
+    [n, o]
+  ), $ = m(
+    (d) => {
+      if (!y) return;
+      const v = I.current.get(d);
+      v && clearTimeout(v), U((S) => /* @__PURE__ */ new Set([...S, d]));
+      const E = setTimeout(() => {
+        U((S) => {
+          const g = new Set(S);
+          return g.delete(d), g;
+        }), I.current.delete(d);
+      }, V);
+      I.current.set(d, E);
+    },
+    [y, V]
+  ), B = m(
+    async (d) => {
+      d.entityName === t && (r && !await r(d) || (L((v) => {
+        const E = Y(v, d);
+        return s == null || s(d, E), E;
+      }), $(d.key)));
+    },
+    [t, r, Y, s, $]
+  ), P = m(
+    (d) => {
+      B(d);
+    },
+    [B]
+  ), oe = m(
+    (d, v) => {
+      if (!C) return;
+      const E = q.find((S) => S[n] === d);
+      E && (J.current.set(d, { original: E, changes: v }), R((S) => /* @__PURE__ */ new Set([...S, d])));
+    },
+    [q, n, C]
+  ), j = m((d) => {
+    J.current.delete(d), R((v) => {
+      const E = new Set(v);
+      return E.delete(d), E;
+    });
+  }, []), F = m((d) => {
+    const v = J.current.get(d);
+    v && (L(
+      (E) => E.map(
+        (S) => S[n] === d ? v.original : S
+      )
+    ), J.current.delete(d), R((E) => {
+      const S = new Set(E);
+      return S.delete(d), S;
+    }));
+  }, [n]), ee = m(async () => {
+    if (e.status === "connected")
+      try {
+        await e.invoke(u, t), Z(null);
+      } catch (d) {
+        Z(d instanceof Error ? d : new Error(String(d)));
+      }
+  }, [e, u, t]), ne = m(async () => {
+    if (e.status === "connected")
+      try {
+        await e.invoke(f, t);
+      } catch {
+      }
+  }, [e, f, t]);
+  return W(() => {
+    const d = e.onStatusChange((v) => {
+      G(v), v === "connected" && ee();
+    });
+    return e.on(b, B), e.status === "connected" && ee(), () => {
+      d(), e.off(b, B), ne(), I.current.forEach((v) => clearTimeout(v)), I.current.clear();
+    };
+  }, [e, b, B, ee, ne]), W(() => {
+    L(a);
+  }, [a]), {
+    data: q,
+    status: Q,
+    flashedKeys: X,
+    pendingKeys: H,
+    error: _,
+    applyRemoteUpdate: P,
+    registerPendingChange: oe,
+    confirmPendingChange: j,
+    rollbackPendingChange: F,
+    resubscribe: ee
+  };
+}
+function Pe(i) {
+  const {
+    adapter: e,
+    entityName: t,
+    keyField: n,
+    fetchMethod: a = "GetEntities",
+    insertMethod: r = "InsertEntity",
+    updateMethod: s = "UpdateEntity",
+    deleteMethod: o = "DeleteEntity"
+  } = i;
+  return {
+    /** Fetch all entities from the hub. */
+    async fetchAll(u) {
+      return e.invoke(a, t, u);
     },
-    on(n, u) {
-      r.on(n, u);
+    /** Insert a new entity via the hub. */
+    async insert(u) {
+      return e.invoke(r, t, u);
     },
-    off(n, u) {
-      r.off(n, u);
+    /** Update an existing entity via the hub. */
+    async update(u, f) {
+      return e.invoke(s, t, u, f);
     },
-    invoke(n, ...u) {
-      return r.invoke(n, ...u);
+    /** Delete an entity via the hub. */
+    async remove(u) {
+      return e.invoke(o, t, u);
     },
-    onStatusChange(n) {
-      return t.add(n), () => t.delete(n);
+    /** Get the key field name. */
+    getKeyField() {
+      return n;
     }
   };
 }
-class w {
+function Te(i, e, t) {
+  const n = new Map(i.map((a) => [a[t], a]));
+  for (const a of e)
+    switch (a.operation) {
+      case "insert":
+        a.data && !n.has(a.key) && n.set(a.key, a.data);
+        break;
+      case "update":
+        if (n.has(a.key)) {
+          const r = n.get(a.key);
+          n.set(
+            a.key,
+            a.data ?? { ...r, ...a.changes }
+          );
+        }
+        break;
+      case "delete":
+        n.delete(a.key);
+        break;
+    }
+  return Array.from(n.values());
+}
+function pe(i) {
+  const {
+    adapter: e,
+    entityType: t,
+    entityId: n,
+    currentUser: a,
+    initialStatus: r = "viewing",
+    heartbeatInterval: s = 3e4,
+    idleTimeout: o = 6e4,
+    awayTimeout: u = 3e5,
+    joinMethod: f = "JoinEntityView",
+    leaveMethod: b = "LeaveEntityView",
+    updateMethod: y = "UpdateEntityPresence",
+    presenceEventName: V = "EntityPresenceChanged",
+    joinedEventName: C = "EntityUserJoined",
+    leftEventName: q = "EntityUserLeft",
+    onPresenceChange: L,
+    onEditConflict: Q
+  } = i, [G, X] = O([]), [U, H] = O(r), [R, _] = O(), [Z, J] = O(e.status), I = ae(Date.now()), Y = ae(null), $ = ae(null), B = ae(null), P = Array.isArray(n) ? n : [n], oe = `${t}:${P.sort().join(",")}`, j = m(
+    async (c, k, w) => {
+      if (e.status === "connected")
+        try {
+          await e.invoke(y, {
+            entityType: t,
+            entityIds: P,
+            userId: a.id,
+            status: c,
+            editingField: k,
+            selection: w,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        } catch {
+        }
+    },
+    [e, y, t, P, a.id]
+  ), F = m(
+    (c, k) => {
+      H(c), _(k), j(c, k), I.current = Date.now();
+    },
+    [j]
+  ), ee = m(
+    (c) => {
+      const k = G.find(
+        (w) => w.user.id !== a.id && w.status === "editing" && w.editingField === c
+      );
+      k && (Q == null || Q(k.user, c)), F("editing", c);
+    },
+    [G, a.id, Q, F]
+  ), ne = m(() => {
+    F("viewing", void 0);
+  }, [F]), d = m(
+    (c) => {
+      j(U, R, c), I.current = Date.now();
+    },
+    [j, U, R]
+  ), v = m(
+    (c) => {
+      const k = G.find(
+        (w) => w.user.id !== a.id && w.status === "editing" && w.editingField === c
+      );
+      return (k == null ? void 0 : k.user) ?? null;
+    },
+    [G, a.id]
+  ), E = m(
+    (c) => {
+      const k = G.find((w) => w.status === "editing" && w.editingField === c);
+      return (k == null ? void 0 : k.user) ?? null;
+    },
+    [G]
+  ), S = m(async () => {
+    if (e.status === "connected")
+      try {
+        const c = await e.invoke("GetEntityPresence", t, P);
+        Array.isArray(c) && (X(c), L == null || L(c));
+      } catch {
+      }
+  }, [e, t, P, L]), g = m(() => {
+    I.current = Date.now(), $.current && clearTimeout($.current), B.current && clearTimeout(B.current), (U === "idle" || U === "away") && F(R ? "editing" : "viewing", R), $.current = setTimeout(() => {
+      F("idle", R);
+    }, o), B.current = setTimeout(() => {
+      F("away", R);
+    }, u);
+  }, [U, R, o, u, F]), N = m(
+    (c) => {
+      c.entityType !== t || !c.entityIds.some((w) => P.includes(w)) || (X(c.presence.filter((w) => w.user.id !== a.id)), L == null || L(c.presence));
+    },
+    [t, P, a.id, L]
+  ), A = m(
+    (c) => {
+      c.entityType !== t || !c.entityIds.some((w) => P.includes(w)) || c.presence.user.id === a.id || X((w) => {
+        const se = w.findIndex((re) => re.user.id === c.presence.user.id);
+        if (se >= 0) {
+          const re = [...w];
+          return re[se] = c.presence, re;
+        }
+        return [...w, c.presence];
+      });
+    },
+    [t, P, a.id]
+  ), K = m(
+    (c) => {
+      c.entityType !== t || !c.entityIds.some((w) => P.includes(w)) || X((w) => w.filter((se) => se.user.id !== c.userId));
+    },
+    [t, P]
+  );
+  W(() => {
+    const c = e.onStatusChange(J);
+    e.on(V, N), e.on(C, A), e.on(q, K);
+    const k = async () => {
+      if (e.status === "connected")
+        try {
+          await e.invoke(f, {
+            entityType: t,
+            entityIds: P,
+            user: a,
+            status: U
+          }), await S();
+        } catch {
+        }
+    };
+    return e.status === "connected" && k(), () => {
+      c(), e.off(V, N), e.off(C, A), e.off(q, K), e.status === "connected" && e.invoke(b, {
+        entityType: t,
+        entityIds: P,
+        userId: a.id
+      }).catch(() => {
+      });
+    };
+  }, [
+    e,
+    oe,
+    f,
+    b,
+    V,
+    C,
+    q,
+    N,
+    A,
+    K,
+    S,
+    a,
+    U,
+    t,
+    P
+  ]), W(() => (Y.current = setInterval(() => {
+    j(U, R);
+  }, s), () => {
+    Y.current && clearInterval(Y.current);
+  }), [s, j, U, R]), W(() => {
+    const c = ["mousemove", "keydown", "mousedown", "touchstart", "scroll"];
+    return c.forEach((k) => window.addEventListener(k, g, { passive: !0 })), $.current = setTimeout(() => {
+      F("idle", R);
+    }, o), B.current = setTimeout(() => {
+      F("away", R);
+    }, u), () => {
+      c.forEach((k) => window.removeEventListener(k, g)), $.current && clearTimeout($.current), B.current && clearTimeout(B.current);
+    };
+  }, [g, o, u, R, F]);
+  const te = G.filter((c) => c.status === "viewing" || c.status === "idle").map((c) => c.user), le = G.filter((c) => c.status === "editing").map((c) => c.user), ue = le.length > 0;
+  return {
+    presence: G,
+    viewers: te,
+    editors: le,
+    myStatus: U,
+    setMyStatus: F,
+    startEditing: ee,
+    stopEditing: ne,
+    updateSelection: d,
+    connectionStatus: Z,
+    isFieldLocked: v,
+    hasActiveEditors: ue,
+    getFieldEditor: E,
+    refresh: S
+  };
+}
+function fe(i) {
+  const e = [
+    "#3b82f6",
+    // blue
+    "#ef4444",
+    // red
+    "#22c55e",
+    // green
+    "#f59e0b",
+    // amber
+    "#8b5cf6",
+    // violet
+    "#ec4899",
+    // pink
+    "#06b6d4",
+    // cyan
+    "#84cc16",
+    // lime
+    "#f97316",
+    // orange
+    "#14b8a6"
+    // teal
+  ];
+  let t = 0;
+  for (let n = 0; n < i.length; n++)
+    t = i.charCodeAt(n) + ((t << 5) - t);
+  return e[Math.abs(t) % e.length];
+}
+function xe(i) {
+  switch (i) {
+    case "viewing":
+      return "Viewing";
+    case "editing":
+      return "Editing";
+    case "idle":
+      return "Idle";
+    case "away":
+      return "Away";
+    default:
+      return "Unknown";
+  }
+}
+function Re(i) {
+  const {
+    adapter: e,
+    entityType: t,
+    currentUser: n,
+    batchEventName: a = "BatchPresenceUpdate"
+  } = i, [r, s] = O(/* @__PURE__ */ new Map()), o = m(
+    (y) => {
+      y.entityType === t && s(new Map(Object.entries(y.presenceByEntity)));
+    },
+    [t]
+  );
+  W(() => (e.on(a, o), () => {
+    e.off(a, o);
+  }), [e, a, o]);
+  const u = m(
+    (y) => r.get(y) ?? [],
+    [r]
+  ), f = m(
+    (y) => {
+      const V = r.get(y);
+      return (V == null ? void 0 : V.some((C) => C.status === "editing" && C.user.id !== n.id)) ?? !1;
+    },
+    [r, n.id]
+  ), b = m(
+    (y) => {
+      const V = r.get(y);
+      return (V == null ? void 0 : V.filter((C) => C.status === "editing").map((C) => C.user)) ?? [];
+    },
+    [r]
+  );
+  return {
+    presenceByEntity: r,
+    getPresence: u,
+    isEntityBeingEdited: f,
+    getEntityEditors: b
+  };
+}
+function M(i) {
+  return `${String(i.rowKey)}:${i.field}`;
+}
+function me(i) {
+  return i ? typeof i == "number" ? i : new Date(i).getTime() : Date.now();
+}
+function De(i) {
+  const {
+    adapter: e,
+    entityType: t,
+    keyField: n,
+    currentUser: a,
+    initialData: r = [],
+    conflictStrategy: s = "last-write-wins",
+    mergeFunction: o,
+    onConflict: u,
+    onBeforeCommit: f,
+    onAfterCommit: b,
+    enableCellLocking: y = !0,
+    lockTimeout: V = 6e4,
+    enableCursorSharing: C = !0,
+    cursorDebounce: q = 50,
+    optimisticUpdates: L = !0,
+    flashChanges: Q = !0,
+    flashDuration: G = 500,
+    liveDataOptions: X = {}
+  } = i, [U, H] = O(/* @__PURE__ */ new Map()), [R, _] = O(/* @__PURE__ */ new Map()), [Z, J] = O([]), [I, Y] = O(null), [$, B] = O([]), [P, oe] = O([]), [j, F] = O(null), [ee, ne] = O([]), d = ae(null), v = ae(/* @__PURE__ */ new Map()), E = m((l) => (v.current.has(l) || v.current.set(l, fe(l)), v.current.get(l)), []), S = m(
+    (l, h, p) => {
+      if (!p.changes) return h;
+      const T = R.get(M({ rowKey: p.key, field: Object.keys(p.changes)[0] }));
+      if (!T) return h;
+      const D = T.timestamp, x = me(p.timestamp);
+      switch (s) {
+        case "last-write-wins":
+          return D > x ? "local" : "remote";
+        case "first-write-wins":
+          return D < x ? "local" : "remote";
+        case "merge":
+          return o ? o(l, h, Object.keys(p.changes)[0]) : "merge";
+        case "ask-user":
+          const z = {
+            cell: { rowKey: p.key, field: Object.keys(p.changes)[0] },
+            localValue: T.newValue,
+            remoteValue: p.changes[Object.keys(p.changes)[0]],
+            localUser: a,
+            remoteUser: p.changedBy ? { id: p.changedBy, name: p.changedBy } : { id: "unknown", name: "Unknown" },
+            localTimestamp: D,
+            remoteTimestamp: x
+          };
+          return J((ie) => [...ie, z]), "local";
+        // Keep local until resolved
+        case "reject":
+          return "remote";
+        default:
+          return "remote";
+      }
+    },
+    [R, s, o, a]
+  ), g = he({
+    adapter: e,
+    entityName: t,
+    keyField: n,
+    initialData: r,
+    flashChanges: Q,
+    flashDuration: G,
+    optimisticUpdates: L,
+    onConflict: S,
+    ...X
+  }), N = pe({
+    adapter: e,
+    entityType: t,
+    entityId: "grid",
+    // Special ID for grid-level presence
+    currentUser: a,
+    initialStatus: "viewing"
+  }), A = m(() => {
+    !C || e.status !== "connected" || e.invoke("UpdateGridSelection", {
+      entityType: t,
+      userId: a.id,
+      focusedCell: I,
+      selectedCells: $,
+      selectedRows: P,
+      editingCell: j
+    }).catch(() => {
+    });
+  }, [e, C, t, a.id, I, $, P, j]);
+  W(() => {
+    if (C)
+      return d.current && clearTimeout(d.current), d.current = setTimeout(A, q), () => {
+        d.current && clearTimeout(d.current);
+      };
+  }, [C, A, q, I, $, P, j]), W(() => {
+    if (!C) return;
+    const l = (h) => {
+      h.entityType !== t || h.userId === a.id || ne((p) => {
+        const T = p.findIndex((x) => x.user.id === h.userId), D = {
+          user: { id: h.userId, name: h.userName, avatarUrl: h.avatarUrl },
+          focusedCell: h.focusedCell,
+          selectedCells: h.selectedCells,
+          selectedRows: h.selectedRows,
+          editingCell: h.editingCell,
+          color: E(h.userId)
+        };
+        if (T >= 0) {
+          const x = [...p];
+          return x[T] = D, x;
+        }
+        return [...p, D];
+      });
+    };
+    return e.on("GridSelectionUpdated", l), () => {
+      e.off("GridSelectionUpdated", l);
+    };
+  }, [e, C, t, a.id, E]), W(() => {
+    if (!y) return;
+    const l = (p) => {
+      p.entityType === t && H((T) => {
+        const D = new Map(T);
+        return D.set(M(p.cell), { user: p.user, timestamp: p.timestamp }), D;
+      });
+    }, h = (p) => {
+      p.entityType === t && H((T) => {
+        const D = new Map(T);
+        return D.delete(M(p.cell)), D;
+      });
+    };
+    return e.on("CellLocked", l), e.on("CellUnlocked", h), () => {
+      e.off("CellLocked", l), e.off("CellUnlocked", h);
+    };
+  }, [e, y, t]), W(() => {
+    if (!y) return;
+    const l = setInterval(() => {
+      const h = Date.now();
+      H((p) => {
+        const T = new Map(p);
+        let D = !1;
+        for (const [x, z] of T)
+          h - z.timestamp > V && (T.delete(x), D = !0);
+        return D ? T : p;
+      });
+    }, 1e4);
+    return () => clearInterval(l);
+  }, [y, V]);
+  const K = m(
+    (l) => {
+      if (!y) return !1;
+      const h = U.get(M(l));
+      return h ? h.user.id !== a.id && Date.now() - h.timestamp < V : !1;
+    },
+    [y, U, a.id, V]
+  ), te = m(
+    (l) => {
+      const h = U.get(M(l));
+      return !h || Date.now() - h.timestamp > V ? null : h.user;
+    },
+    [U, V]
+  ), le = m(
+    (l) => K(l) ? !1 : (F(l), N.startEditing(`${l.rowKey}:${l.field}`), y && e.status === "connected" && (e.invoke("AcquireCellLock", {
+      entityType: t,
+      cell: l,
+      user: a,
+      timestamp: Date.now()
+    }).catch(() => {
+    }), H((h) => {
+      const p = new Map(h);
+      return p.set(M(l), { user: a, timestamp: Date.now() }), p;
+    })), !0),
+    [K, N, y, e, t, a]
+  ), ue = m(
+    async (l, h) => {
+      const p = g.data.find((x) => x[n] === l.rowKey);
+      if (!p) return !1;
+      const T = p[l.field];
+      if (f && !await f(l, T, h))
+        return c(l), !1;
+      const D = {
+        cell: l,
+        originalValue: T,
+        newValue: h,
+        timestamp: Date.now()
+      };
+      _((x) => {
+        const z = new Map(x);
+        return z.set(M(l), D), z;
+      }), L && g.registerPendingChange(l.rowKey, { [l.field]: h });
+      try {
+        return await e.invoke("UpdateEntityField", {
+          entityType: t,
+          entityId: l.rowKey,
+          field: l.field,
+          value: h,
+          userId: a.id,
+          timestamp: D.timestamp
+        }), g.confirmPendingChange(l.rowKey), _((x) => {
+          const z = new Map(x);
+          return z.delete(M(l)), z;
+        }), b == null || b(l, h), y && (e.invoke("ReleaseCellLock", { entityType: t, cell: l }).catch(() => {
+        }), H((x) => {
+          const z = new Map(x);
+          return z.delete(M(l)), z;
+        })), F(null), N.stopEditing(), !0;
+      } catch (x) {
+        throw g.rollbackPendingChange(l.rowKey), _((z) => {
+          const ie = new Map(z);
+          return ie.delete(M(l)), ie;
+        }), x;
+      }
+    },
+    [
+      g,
+      n,
+      f,
+      L,
+      e,
+      t,
+      a.id,
+      b,
+      y,
+      N
+    ]
+  ), c = m(
+    (l) => {
+      F(null), N.stopEditing(), y && e.status === "connected" && (e.invoke("ReleaseCellLock", { entityType: t, cell: l }).catch(() => {
+      }), H((h) => {
+        const p = new Map(h);
+        return p.delete(M(l)), p;
+      })), _((h) => {
+        const p = new Map(h);
+        return p.delete(M(l)), p;
+      });
+    },
+    [N, y, e, t]
+  ), k = m(
+    (l, h) => {
+      const p = Z.find((T) => M(T.cell) === M(l));
+      p && (h === "remote" && g.applyRemoteUpdate({
+        operation: "update",
+        entityName: t,
+        key: l.rowKey,
+        changes: { [l.field]: p.remoteValue }
+      }), J((T) => T.filter((D) => M(D.cell) !== M(l))));
+    },
+    [Z, g, t]
+  ), w = m(
+    async (l) => {
+      await e.invoke("InsertEntity", t, l);
+    },
+    [e, t]
+  ), se = m(
+    async (l, h) => {
+      L && g.registerPendingChange(l, h);
+      try {
+        await e.invoke("UpdateEntity", t, l, h), g.confirmPendingChange(l);
+      } catch (p) {
+        throw g.rollbackPendingChange(l), p;
+      }
+    },
+    [e, t, L, g]
+  ), re = m(
+    async (l) => {
+      await e.invoke("DeleteEntity", t, l);
+    },
+    [e, t]
+  ), ce = de(
+    () => ({
+      user: a,
+      focusedCell: I,
+      selectedCells: $,
+      selectedRows: P,
+      editingCell: j,
+      color: E(a.id)
+    }),
+    [a, I, $, P, j, E]
+  );
+  return {
+    data: g.data,
+    presence: N.presence,
+    userSelections: ee,
+    mySelection: ce,
+    flashedKeys: g.flashedKeys,
+    pendingEdits: R,
+    connectionStatus: g.status,
+    myPresenceStatus: N.myStatus,
+    // Selection methods
+    setFocusedCell: Y,
+    setSelectedCells: B,
+    setSelectedRows: oe,
+    // Edit methods
+    startCellEdit: le,
+    commitCellEdit: ue,
+    cancelCellEdit: c,
+    isCellLocked: K,
+    getCellEditor: te,
+    getUserColor: E,
+    // Row methods
+    insertRow: w,
+    updateRow: se,
+    deleteRow: re,
+    // Conflict handling
+    resolveConflict: k,
+    conflicts: Z
+  };
+}
+class Ae {
   constructor(e) {
     this.accessToken = null, this.refreshToken = null, this.tokenFactory = async () => {
       if (!this.accessToken) throw new Error("Not authenticated");
@@ -87,35 +840,35 @@ class w {
   getAccessToken() {
     return this.accessToken;
   }
-  async post(e, a) {
-    const l = await (this.cfg.fetch ?? globalThis.fetch)(`${this.cfg.baseUrl}${e}`, {
+  async post(e, t) {
+    const a = await (this.cfg.fetch ?? globalThis.fetch)(`${this.cfg.baseUrl}${e}`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(a)
+      body: JSON.stringify(t)
     });
-    if (!l.ok) throw new Error(`Auth request failed: ${l.status}`);
-    return l.json();
+    if (!a.ok) throw new Error(`Auth request failed: ${a.status}`);
+    return a.json();
   }
   /** Login with username/password. */
   async login(e) {
-    var t, l;
-    const a = await this.post("/login", e);
-    return a.token && (this.accessToken = a.token, this.refreshToken = a.refreshToken ?? null, (l = (t = this.cfg).onTokens) == null || l.call(t, a.token, a.refreshToken ?? "")), a;
+    var n, a;
+    const t = await this.post("/login", e);
+    return t.token && (this.accessToken = t.token, this.refreshToken = t.refreshToken ?? null, (a = (n = this.cfg).onTokens) == null || a.call(n, t.token, t.refreshToken ?? "")), t;
   }
   /** Refresh the access token. */
   async refresh() {
-    var a, t;
+    var t, n;
     if (!this.refreshToken) throw new Error("No refresh token");
     const e = await this.post("/refresh", { refreshToken: this.refreshToken });
-    return e.token && (this.accessToken = e.token, this.refreshToken = e.refreshToken ?? this.refreshToken, (t = (a = this.cfg).onTokens) == null || t.call(a, e.token, this.refreshToken)), e;
+    return e.token && (this.accessToken = e.token, this.refreshToken = e.refreshToken ?? this.refreshToken, (n = (t = this.cfg).onTokens) == null || n.call(t, e.token, this.refreshToken)), e;
   }
   /** Get current user info. */
   async me() {
-    const a = await (this.cfg.fetch ?? globalThis.fetch)(`${this.cfg.baseUrl}/me`, {
+    const t = await (this.cfg.fetch ?? globalThis.fetch)(`${this.cfg.baseUrl}/me`, {
       headers: { Authorization: `Bearer ${this.accessToken}` }
     });
-    if (!a.ok) throw new Error(`Auth /me failed: ${a.status}`);
-    return a.json();
+    if (!t.ok) throw new Error(`Auth /me failed: ${t.status}`);
+    return t.json();
   }
   /** Logout (invalidate tokens on server). */
   async logout() {
@@ -129,7 +882,7 @@ class w {
     }
   }
 }
-class V {
+class Le {
   constructor(e) {
     this.cfg = e;
   }
@@ -138,57 +891,111 @@ class V {
     return this.cfg.tokenFactory && (e.Authorization = `Bearer ${await this.cfg.tokenFactory()}`), e;
   }
   /** Upload a file. Returns file metadata on success. */
-  async upload(e, a) {
-    const t = this.cfg.fetch ?? globalThis.fetch, l = new FormData();
-    l.append("file", e), a && l.append("folder", a);
-    const o = await t(this.cfg.baseUrl, {
+  async upload(e, t) {
+    const n = this.cfg.fetch ?? globalThis.fetch, a = new FormData();
+    a.append("file", e), t && a.append("folder", t);
+    const r = await n(this.cfg.baseUrl, {
       method: "POST",
       headers: await this.headers(),
-      body: l
+      body: a
     });
-    if (!o.ok) throw new Error(`File upload failed: ${o.status}`);
-    return o.json();
+    if (!r.ok) throw new Error(`File upload failed: ${r.status}`);
+    return r.json();
   }
   /** Upload multiple files. */
-  async uploadMultiple(e, a) {
-    const t = this.cfg.fetch ?? globalThis.fetch, l = new FormData();
-    e.forEach((r) => l.append("files", r)), a && l.append("folder", a);
-    const o = await t(`${this.cfg.baseUrl}/batch`, {
+  async uploadMultiple(e, t) {
+    const n = this.cfg.fetch ?? globalThis.fetch, a = new FormData();
+    e.forEach((s) => a.append("files", s)), t && a.append("folder", t);
+    const r = await n(`${this.cfg.baseUrl}/batch`, {
       method: "POST",
       headers: await this.headers(),
-      body: l
+      body: a
     });
-    if (!o.ok) throw new Error(`Batch upload failed: ${o.status}`);
-    return o.json();
+    if (!r.ok) throw new Error(`Batch upload failed: ${r.status}`);
+    return r.json();
   }
   /** Get file metadata by id. */
   async getInfo(e) {
-    const t = await (this.cfg.fetch ?? globalThis.fetch)(`${this.cfg.baseUrl}/${e}/info`, {
+    const n = await (this.cfg.fetch ?? globalThis.fetch)(`${this.cfg.baseUrl}/${e}/info`, {
       headers: { ...await this.headers(), "Content-Type": "application/json" }
     });
-    if (!t.ok) throw new Error(`File info failed: ${t.status}`);
-    return t.json();
+    if (!n.ok) throw new Error(`File info failed: ${n.status}`);
+    return n.json();
   }
   /** Get a download URL (or blob URL) for a file. */
   async getDownloadUrl(e) {
-    const t = await (this.cfg.fetch ?? globalThis.fetch)(`${this.cfg.baseUrl}/${e}`, {
+    const n = await (this.cfg.fetch ?? globalThis.fetch)(`${this.cfg.baseUrl}/${e}`, {
       headers: await this.headers()
     });
-    if (!t.ok) throw new Error(`File download failed: ${t.status}`);
-    const l = await t.blob();
-    return URL.createObjectURL(l);
+    if (!n.ok) throw new Error(`File download failed: ${n.status}`);
+    const a = await n.blob();
+    return URL.createObjectURL(a);
   }
   /** Delete file by id. */
   async remove(e) {
-    const t = await (this.cfg.fetch ?? globalThis.fetch)(`${this.cfg.baseUrl}/${e}`, {
+    const n = await (this.cfg.fetch ?? globalThis.fetch)(`${this.cfg.baseUrl}/${e}`, {
       method: "DELETE",
       headers: { ...await this.headers(), "Content-Type": "application/json" }
     });
-    if (!t.ok) throw new Error(`File delete failed: ${t.status}`);
-    return t.json();
+    if (!n.ok) throw new Error(`File delete failed: ${n.status}`);
+    return n.json();
+  }
+  /**
+   * Upload a file with progress tracking via XMLHttpRequest.
+   * Falls back to standard fetch-based upload if XHR is unavailable.
+   */
+  uploadWithProgress(e, t, n, a) {
+    return typeof XMLHttpRequest > "u" ? this.upload(e, n) : new Promise(async (r, s) => {
+      const o = new XMLHttpRequest(), u = new FormData();
+      if (u.append("file", e), n && u.append("folder", n), a) {
+        if (a.aborted) {
+          s(new DOMException("Aborted", "AbortError"));
+          return;
+        }
+        a.addEventListener("abort", () => {
+          o.abort(), s(new DOMException("Aborted", "AbortError"));
+        });
+      }
+      o.upload.addEventListener("progress", (b) => {
+        t({
+          loaded: b.loaded,
+          total: b.total,
+          percent: b.lengthComputable ? b.loaded / b.total : NaN
+        });
+      }), o.addEventListener("load", () => {
+        if (o.status >= 200 && o.status < 300)
+          try {
+            r(JSON.parse(o.responseText));
+          } catch {
+            s(new Error("Invalid JSON response"));
+          }
+        else
+          s(new Error(`File upload failed: ${o.status}`));
+      }), o.addEventListener("error", () => s(new Error("Network error during upload"))), o.addEventListener("abort", () => s(new DOMException("Aborted", "AbortError"))), o.open("POST", this.cfg.baseUrl);
+      const f = await this.headers();
+      Object.entries(f).forEach(([b, y]) => o.setRequestHeader(b, y)), o.send(u);
+    });
+  }
+  /**
+   * Upload multiple files with per-file progress tracking.
+   * Returns progress for each file individually.
+   */
+  async uploadMultipleWithProgress(e, t, n, a) {
+    const r = [];
+    for (let s = 0; s < e.length; s++) {
+      if (a != null && a.aborted) throw new DOMException("Aborted", "AbortError");
+      const o = await this.uploadWithProgress(
+        e[s],
+        (u) => t(s, u),
+        n,
+        a
+      );
+      r.push(o);
+    }
+    return r;
   }
 }
-class v {
+class Ue {
   constructor(e) {
     this.cfg = e;
   }
@@ -198,32 +1005,346 @@ class v {
   }
   /** Request a server-side export. Returns a download URL / job id. */
   async requestExport(e) {
-    const t = await (this.cfg.fetch ?? globalThis.fetch)(this.cfg.baseUrl, {
+    const n = await (this.cfg.fetch ?? globalThis.fetch)(this.cfg.baseUrl, {
       method: "POST",
       headers: await this.headers(),
       body: JSON.stringify(e)
     });
-    if (!t.ok) throw new Error(`Export request failed: ${t.status}`);
-    return t.json();
+    if (!n.ok) throw new Error(`Export request failed: ${n.status}`);
+    return n.json();
   }
   /** Download an exported file as a Blob. */
   async download(e) {
-    const t = await (this.cfg.fetch ?? globalThis.fetch)(e, {
+    const n = await (this.cfg.fetch ?? globalThis.fetch)(e, {
       headers: await this.headers()
     });
-    if (!t.ok) throw new Error(`Export download failed: ${t.status}`);
-    return t.blob();
+    if (!n.ok) throw new Error(`Export download failed: ${n.status}`);
+    return n.blob();
   }
   /** Trigger browser download for an export. */
-  async downloadToFile(e, a) {
-    var i;
-    const t = await this.requestExport(e);
-    if (!((i = t.data) != null && i.downloadUrl)) throw new Error("No download URL returned");
-    const l = await this.download(t.data.downloadUrl), o = URL.createObjectURL(l), r = document.createElement("a");
-    r.href = o, r.download = a ?? `export.${e.format}`, document.body.appendChild(r), r.click(), document.body.removeChild(r), URL.revokeObjectURL(o);
+  async downloadToFile(e, t) {
+    var o;
+    const n = await this.requestExport(e);
+    if (!((o = n.data) != null && o.downloadUrl)) throw new Error("No download URL returned");
+    const a = await this.download(n.data.downloadUrl), r = URL.createObjectURL(a), s = document.createElement("a");
+    s.href = r, s.download = t ?? `export.${e.format}`, document.body.appendChild(s), s.click(), document.body.removeChild(s), URL.revokeObjectURL(r);
+  }
+}
+function Fe(i) {
+  return (e) => {
+    const t = e ?? globalThis.fetch;
+    return (a, r) => {
+      const u = { url: typeof a == "string" ? a : a instanceof URL ? a.toString() : a.url, init: r ?? {}, meta: {} };
+      let f = (b) => t(b.url, b.init);
+      for (let b = i.length - 1; b >= 0; b--) {
+        const y = i[b], V = f;
+        f = (C) => y(C, V);
+      }
+      return f(u);
+    };
+  };
+}
+function Oe() {
+  return async (i, e) => {
+    const t = performance.now(), n = (i.init.method ?? "GET").toUpperCase();
+    try {
+      const a = await e(i), r = (performance.now() - t).toFixed(1);
+      return console.debug(`[ERP] ${n} ${i.url} → ${a.status} (${r}ms)`), a;
+    } catch (a) {
+      const r = (performance.now() - t).toFixed(1);
+      throw console.error(`[ERP] ${n} ${i.url} FAILED (${r}ms)`, a), a;
+    }
+  };
+}
+function Ne(i) {
+  const e = (i == null ? void 0 : i.maxRetries) ?? 3, t = (i == null ? void 0 : i.baseDelay) ?? 500, n = new Set((i == null ? void 0 : i.retryOn) ?? [408, 429, 500, 502, 503, 504]);
+  return async (a, r) => {
+    let s;
+    for (let o = 0; o <= e; o++) {
+      try {
+        const f = await r(a);
+        if (f.ok || !n.has(f.status) || o === e)
+          return f;
+        s = new Error(`HTTP ${f.status}`);
+      } catch (f) {
+        if (s = f, o === e) throw f;
+      }
+      const u = t * Math.pow(2, o) * (0.5 + Math.random() * 0.5);
+      await new Promise((f) => setTimeout(f, u));
+    }
+    throw s;
+  };
+}
+function Me(i) {
+  return async (e, t) => {
+    const n = typeof i == "function" ? await i() : i;
+    return e.init.headers = { ...e.init.headers, ...n }, t(e);
+  };
+}
+class Ie {
+  constructor(e) {
+    this.inFlight = 0, this.timestamps = [], this.queue = [], this.processing = !1, this.backingOff = !1, this.maxConcurrent = (e == null ? void 0 : e.maxConcurrent) ?? 6, this.maxPerSecond = (e == null ? void 0 : e.maxPerSecond) ?? 20, this.backoffDelay = (e == null ? void 0 : e.backoffDelay) ?? 2e3, this.baseFetch = (e == null ? void 0 : e.baseFetch) ?? globalThis.fetch.bind(globalThis), this.fetch = this.fetch.bind(this);
+  }
+  /** A fetch-compatible function that respects rate limits. */
+  fetch(e, t) {
+    return new Promise((n, a) => {
+      this.queue.push({ resolve: n, reject: a, input: e, init: t }), this.drain();
+    });
+  }
+  /** Number of requests currently waiting in the queue. */
+  get pending() {
+    return this.queue.length;
+  }
+  /** Number of requests currently in flight. */
+  get active() {
+    return this.inFlight;
+  }
+  drain() {
+    if (this.processing) return;
+    this.processing = !0;
+    const e = () => {
+      if (this.queue.length === 0 || this.backingOff) {
+        this.processing = !1;
+        return;
+      }
+      if (this.inFlight >= this.maxConcurrent) {
+        this.processing = !1;
+        return;
+      }
+      const t = Date.now();
+      if (this.timestamps = this.timestamps.filter((a) => t - a < 1e3), this.timestamps.length >= this.maxPerSecond) {
+        const a = this.timestamps[0], r = 1e3 - (t - a) + 1;
+        setTimeout(() => {
+          this.processing = !1, this.drain();
+        }, r);
+        return;
+      }
+      const n = this.queue.shift();
+      this.inFlight++, this.timestamps.push(t), this.baseFetch(n.input, n.init).then((a) => {
+        if (this.inFlight--, a.status === 429) {
+          this.queue.unshift(n), this.inFlight++, this.inFlight--, this.backingOff = !0, setTimeout(() => {
+            this.backingOff = !1, this.drain();
+          }, this.backoffDelay);
+          return;
+        }
+        n.resolve(a), queueMicrotask(e);
+      }).catch((a) => {
+        this.inFlight--, n.reject(a), queueMicrotask(e);
+      }), queueMicrotask(e);
+    };
+    e();
+  }
+}
+class $e {
+  constructor(e, t = "id") {
+    this.items = [], this.mutations = [], this.listeners = /* @__PURE__ */ new Set(), this.nextMutationId = 1, this.adapter = e, this.keyField = t;
+  }
+  /** Subscribe to state changes. Returns unsubscribe function. */
+  subscribe(e) {
+    return this.listeners.add(e), () => this.listeners.delete(e);
+  }
+  notify() {
+    const e = [...this.items], t = [...this.mutations];
+    this.listeners.forEach((n) => n(e, t));
+  }
+  /** Current items including optimistic (unconfirmed) changes. */
+  getItems() {
+    return [...this.items];
+  }
+  /** Pending mutations not yet confirmed by server. */
+  getPending() {
+    return this.mutations.filter((e) => e.status === "pending");
+  }
+  /** Set initial data (e.g. after load()). */
+  setItems(e) {
+    this.items = [...e], this.notify();
+  }
+  /** Load data from server and replace local state. */
+  async load(...e) {
+    const t = await this.adapter.load(...e);
+    return t.success && (this.items = t.data, this.mutations = [], this.notify()), t;
+  }
+  /** Optimistically create an item. */
+  async create(e) {
+    const t = `__temp_${this.nextMutationId}`, n = { ...e, [this.keyField]: t }, r = {
+      id: String(this.nextMutationId++),
+      type: "create",
+      optimisticData: n,
+      timestamp: Date.now(),
+      status: "pending"
+    };
+    this.items = [...this.items, n], this.mutations.push(r), this.notify();
+    try {
+      const s = await this.adapter.create(e);
+      return s.success ? (this.items = this.items.map(
+        (o) => o[this.keyField] === t ? s.data : o
+      ), r.status = "confirmed", r.entityId = s.data[this.keyField]) : (this.items = this.items.filter(
+        (o) => o[this.keyField] !== t
+      ), r.status = "failed", r.error = s.error), this.notify(), s;
+    } catch (s) {
+      throw this.items = this.items.filter(
+        (o) => o[this.keyField] !== t
+      ), r.status = "failed", r.error = s instanceof Error ? s.message : String(s), this.notify(), s;
+    }
+  }
+  /** Optimistically update an item. */
+  async update(e, t) {
+    const n = this.items.findIndex(
+      (o) => o[this.keyField] === e
+    ), a = n >= 0 ? { ...this.items[n] } : void 0, s = {
+      id: String(this.nextMutationId++),
+      type: "update",
+      entityId: e,
+      previousData: a,
+      timestamp: Date.now(),
+      status: "pending"
+    };
+    n >= 0 && (this.items = this.items.map(
+      (o, u) => u === n ? { ...o, ...t } : o
+    )), this.mutations.push(s), this.notify();
+    try {
+      const o = await this.adapter.update(e, t);
+      return o.success ? (this.items = this.items.map(
+        (u) => u[this.keyField] === e ? o.data : u
+      ), s.status = "confirmed") : (a && n >= 0 && (this.items = this.items.map(
+        (u) => u[this.keyField] === e ? a : u
+      )), s.status = "failed", s.error = o.error), this.notify(), o;
+    } catch (o) {
+      throw a && n >= 0 && (this.items = this.items.map(
+        (u) => u[this.keyField] === e ? a : u
+      )), s.status = "failed", s.error = o instanceof Error ? o.message : String(o), this.notify(), o;
+    }
+  }
+  /** Optimistically delete an item. */
+  async remove(e) {
+    const t = this.items.findIndex(
+      (s) => s[this.keyField] === e
+    ), n = t >= 0 ? { ...this.items[t] } : void 0, r = {
+      id: String(this.nextMutationId++),
+      type: "delete",
+      entityId: e,
+      previousData: n,
+      timestamp: Date.now(),
+      status: "pending"
+    };
+    this.items = this.items.filter(
+      (s) => s[this.keyField] !== e
+    ), this.mutations.push(r), this.notify();
+    try {
+      const s = await this.adapter.remove(e);
+      return s.success ? r.status = "confirmed" : (n && this.items.splice(t, 0, n), r.status = "failed", r.error = s.error), this.notify(), s;
+    } catch (s) {
+      throw n && this.items.splice(t, 0, n), r.status = "failed", r.error = s instanceof Error ? s.message : String(s), this.notify(), s;
+    }
+  }
+}
+class Be {
+  constructor(e) {
+    this.queue = [], this.syncing = !1, this.nextId = 1, this.config = e ?? {}, this.baseFetch = (e == null ? void 0 : e.baseFetch) ?? globalThis.fetch.bind(globalThis), this.storageKey = (e == null ? void 0 : e.storageKey) ?? "erp_offline_", this.fetch = this.fetch.bind(this), this.restoreQueue(), this.boundOnline = () => {
+      var t, n;
+      (n = (t = this.config).onStatusChange) == null || n.call(t, !0), this.sync();
+    }, this.boundOffline = () => {
+      var t, n;
+      (n = (t = this.config).onStatusChange) == null || n.call(t, !1);
+    }, typeof window < "u" && (window.addEventListener("online", this.boundOnline), window.addEventListener("offline", this.boundOffline));
+  }
+  /** A fetch-compatible function that queues mutations when offline. */
+  fetch(e, t) {
+    var s, o;
+    const n = typeof e == "string" ? e : e instanceof URL ? e.toString() : e.url, a = ((t == null ? void 0 : t.method) ?? "GET").toUpperCase();
+    if (this.isOnline())
+      return this.baseFetch(e, t);
+    if (a === "GET" || a === "HEAD")
+      return Promise.reject(new Error("Offline: GET requests are not queued"));
+    const r = {
+      id: `q_${this.nextId++}`,
+      url: n,
+      method: a,
+      headers: { ...t == null ? void 0 : t.headers },
+      body: typeof (t == null ? void 0 : t.body) == "string" ? t.body : void 0,
+      timestamp: Date.now()
+    };
+    return this.queue.push(r), this.persistQueue(), (o = (s = this.config).onQueued) == null || o.call(s, r), Promise.resolve(new Response(
+      JSON.stringify({ queued: !0, queueId: r.id }),
+      { status: 202, headers: { "Content-Type": "application/json" } }
+    ));
+  }
+  /** Is the browser currently online? */
+  isOnline() {
+    return typeof navigator > "u" || navigator.onLine;
+  }
+  /** Number of entries waiting to be synced. */
+  get pendingCount() {
+    return this.queue.length;
+  }
+  /** Get a snapshot of the current queue. */
+  getQueue() {
+    return [...this.queue];
+  }
+  /** Clear all pending entries without syncing. */
+  clear() {
+    this.queue = [], this.persistQueue();
+  }
+  /** Manually trigger sync (e.g. when you detect connectivity). */
+  async sync() {
+    var t, n;
+    if (this.syncing || this.queue.length === 0 || !this.isOnline())
+      return [];
+    this.syncing = !0;
+    const e = [];
+    for (; this.queue.length > 0 && this.isOnline(); ) {
+      const a = this.queue[0];
+      try {
+        const r = await this.baseFetch(a.url, {
+          method: a.method,
+          headers: a.headers,
+          body: a.body
+        });
+        e.push({
+          entry: a,
+          success: r.ok,
+          status: r.status,
+          error: r.ok ? void 0 : `HTTP ${r.status}`
+        }), this.queue.shift();
+      } catch (r) {
+        e.push({
+          entry: a,
+          success: !1,
+          error: r instanceof Error ? r.message : String(r)
+        });
+        break;
+      }
+    }
+    return this.persistQueue(), this.syncing = !1, e.length > 0 && ((n = (t = this.config).onSync) == null || n.call(t, e)), e;
+  }
+  /** Remove event listeners. */
+  destroy() {
+    typeof window < "u" && (window.removeEventListener("online", this.boundOnline), window.removeEventListener("offline", this.boundOffline));
+  }
+  persistQueue() {
+    try {
+      typeof localStorage < "u" && localStorage.setItem(
+        `${this.storageKey}queue`,
+        JSON.stringify(this.queue)
+      );
+    } catch {
+    }
+  }
+  restoreQueue() {
+    try {
+      if (typeof localStorage < "u") {
+        const e = localStorage.getItem(`${this.storageKey}queue`);
+        e && (this.queue = JSON.parse(e), this.nextId = this.queue.reduce(
+          (t, n) => Math.max(t, parseInt(n.id.replace("q_", ""), 10) || 0),
+          0
+        ) + 1);
+      }
+    } catch {
+      this.queue = [];
+    }
   }
 }
-const c = [
+const ye = [
   {
     type: "NiceAudioPlayer",
     label: "Audio Player",
@@ -295,7 +1416,7 @@ const c = [
       { name: "fontSize", type: "size", label: "Font size", group: "Typography" }
     ]
   }
-], p = [
+], be = [
   {
     type: "NicePixelEditor",
     label: "Pixel Editor",
@@ -350,7 +1471,7 @@ const c = [
       { name: "maxWidth", type: "number", label: "Max output width", min: 100, max: 8192, group: "Output" }
     ]
   }
-], d = [
+], ge = [
   {
     type: "NiceModelEditor",
     label: "3D Model Editor",
@@ -396,7 +1517,7 @@ const c = [
       { name: "height", type: "size", label: "Viewport height", group: "Layout" }
     ]
   }
-], b = [
+], we = [
   {
     type: "NiceLeaderboard",
     label: "Leaderboard",
@@ -468,7 +1589,7 @@ const c = [
       { name: "height", type: "size", label: "Bar height", group: "Layout" }
     ]
   }
-], m = [
+], ve = [
   {
     type: "NiceAddress",
     label: "Address Editor",
@@ -567,7 +1688,7 @@ const c = [
       { name: "readOnly", type: "boolean", label: "Read only", defaultValue: !1 }
     ]
   }
-], h = [
+], ke = [
   {
     type: "NiceLoginForm",
     label: "Login Form",
@@ -628,7 +1749,7 @@ const c = [
       { name: "codeLength", type: "number", label: "Code length", min: 4, max: 8, defaultValue: 6 }
     ]
   }
-], f = [
+], Se = [
   {
     type: "NiceComments",
     label: "Comments",
@@ -686,28 +1807,43 @@ const c = [
       { name: "maxLength", type: "number", label: "Max content length", min: 0, defaultValue: 0 }
     ]
   }
-], S = [
-  ...c,
-  ...p,
-  ...d,
-  ...b,
-  ...m,
-  ...h,
-  ...f
+], je = [
+  ...ye,
+  ...be,
+  ...ge,
+  ...we,
+  ...ve,
+  ...ke,
+  ...Se
 ];
 export {
-  w as ErpAuthAdapter,
-  y as ErpDataAdapter,
-  v as ErpExportAdapter,
-  V as ErpFileAdapter,
-  S as allControlRegistries,
-  c as audioControlRegistry,
-  h as authControlRegistry,
-  m as businessControlRegistry,
-  g as createSignalRAdapter,
-  b as gamificationControlRegistry,
-  p as graphicControlRegistry,
-  f as socialControlRegistry,
-  d as threeControlRegistry
+  Ae as ErpAuthAdapter,
+  Ve as ErpDataAdapter,
+  Ue as ErpExportAdapter,
+  Le as ErpFileAdapter,
+  Be as ErpOfflineQueue,
+  $e as ErpOptimisticStore,
+  Ie as ErpRateLimiter,
+  je as allControlRegistries,
+  Te as applyBatchChanges,
+  ye as audioControlRegistry,
+  ke as authControlRegistry,
+  ve as businessControlRegistry,
+  Fe as createMiddlewarePipeline,
+  Ce as createSignalRAdapter,
+  Pe as createSignalRDataOperations,
+  xe as formatPresenceStatus,
+  we as gamificationControlRegistry,
+  fe as generateUserColor,
+  be as graphicControlRegistry,
+  Me as headerMiddleware,
+  Oe as loggingMiddleware,
+  Ne as retryMiddleware,
+  Se as socialControlRegistry,
+  ge as threeControlRegistry,
+  De as useCollaborativeDataGrid,
+  pe as useEntityPresence,
+  Re as useMultiEntityPresence,
+  he as useSignalRLiveData
 };
 //# sourceMappingURL=index.mjs.map