@flamingo-stack/openframe-frontend-core 0.0.212 → 0.0.213

package/dist/chunk-OZ3GH6OQ.cjs

@@ -0,0 +1,698 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }"use client";
+
+// src/nats/nats.ts
+function assertClientSide() {
+  if (typeof window === "undefined") {
+    throw new Error("NATS client can only connect from the browser/runtime with WebSocket support (window is undefined).");
+  }
+}
+async function importNats() {
+  return await Promise.resolve().then(() => _interopRequireWildcard(require("nats.ws")));
+}
+function toNatsHeaders(nats, init) {
+  if (!init) return void 0;
+  if (typeof init.get === "function") return init;
+  const h = nats.headers();
+  for (const [k, v] of Object.entries(init)) {
+    if (v !== void 0 && v !== null) h.set(k, String(v));
+  }
+  return h;
+}
+function cryptoRandom() {
+  const buf = new Uint32Array(1);
+  crypto.getRandomValues(buf);
+  return buf[0] / (4294967295 + 1);
+}
+function createExponentialBackoffHandler(opts) {
+  const initialDelay = _nullishCoalesce(opts.initialDelayMs, () => ( 1e3));
+  const maxDelay = _nullishCoalesce(opts.maxDelayMs, () => ( 3e4));
+  const multiplier = _nullishCoalesce(opts.multiplier, () => ( 2));
+  const jitter = _nullishCoalesce(opts.jitter, () => ( true));
+  let attempt = 0;
+  return {
+    handler: () => {
+      const delay = Math.min(initialDelay * multiplier ** attempt, maxDelay);
+      attempt++;
+      return jitter ? delay * (0.5 + cryptoRandom() * 0.5) : delay;
+    },
+    reset: () => {
+      attempt = 0;
+    }
+  };
+}
+function mapOptionsToConnectionOptions(opts, backoff) {
+  return {
+    servers: opts.servers,
+    name: opts.name,
+    token: opts.token,
+    user: opts.user,
+    pass: opts.pass,
+    timeout: _nullishCoalesce(opts.connectTimeoutMs, () => ( 15e3)),
+    reconnect: _nullishCoalesce(opts.reconnect, () => ( true)),
+    maxReconnectAttempts: opts.maxReconnectAttempts,
+    reconnectTimeWait: opts.reconnectTimeWaitMs,
+    reconnectDelayHandler: _optionalChain([backoff, 'optionalAccess', _ => _.handler]),
+    pingInterval: opts.pingIntervalMs,
+    maxPingOut: opts.maxPingOut,
+    inboxPrefix: opts.inboxPrefix
+  };
+}
+function mapNatsTypeToStatus(type) {
+  const t = String(type).toLowerCase();
+  if (t.includes("disconnect")) return "disconnected";
+  if (t === "reconnecting") return "reconnecting";
+  if (t === "reconnect" || t.includes("connect")) return "connected";
+  if (t.includes("error")) return "error";
+  if (t.includes("close")) return "closed";
+  return null;
+}
+function createNatsClient(options) {
+  let nc = null;
+  let statusLoopAbort = null;
+  let connectInFlight = null;
+  const backoff = options.exponentialBackoff ? createExponentialBackoffHandler(options.exponentialBackoff) : void 0;
+  const statusListeners = /* @__PURE__ */ new Set();
+  function emitStatus(event) {
+    for (const listener of statusListeners) {
+      try {
+        listener(event);
+      } catch (e2) {
+      }
+    }
+  }
+  async function connect() {
+    if (nc && !nc.isClosed()) return;
+    if (connectInFlight) return connectInFlight;
+    assertClientSide();
+    connectInFlight = (async () => {
+      try {
+        emitStatus({ status: "connecting" });
+        const nats = await importNats();
+        const conn = await nats.connect(mapOptionsToConnectionOptions(options, backoff));
+        nc = conn;
+        emitStatus({ status: "connected" });
+        statusLoopAbort = new AbortController();
+        const signal = statusLoopAbort.signal;
+        (async () => {
+          try {
+            for await (const s of conn.status()) {
+              if (signal.aborted) return;
+              const mapped = mapNatsTypeToStatus(_optionalChain([s, 'optionalAccess', _2 => _2.type]));
+              if (mapped) {
+                if (mapped === "connected" && backoff) {
+                  backoff.reset();
+                }
+                emitStatus({ status: mapped, data: _optionalChain([s, 'optionalAccess', _3 => _3.data]) });
+                if (mapped === "closed") {
+                  nc = null;
+                }
+              }
+            }
+          } catch (e) {
+            if (!signal.aborted) {
+              emitStatus({ status: "error", data: e });
+              nc = null;
+            }
+          }
+        })().catch(() => {
+        });
+      } finally {
+        connectInFlight = null;
+      }
+    })();
+    return connectInFlight;
+  }
+  async function close() {
+    const conn = nc;
+    nc = null;
+    if (statusLoopAbort) {
+      try {
+        statusLoopAbort.abort();
+      } catch (e3) {
+      }
+      statusLoopAbort = null;
+    }
+    if (!conn) return;
+    try {
+      await conn.drain();
+    } finally {
+      try {
+        await conn.close();
+      } finally {
+        emitStatus({ status: "closed" });
+      }
+    }
+  }
+  function requireConnection() {
+    if (!nc) throw new Error("NATS is not connected. Call client.connect() first.");
+    return nc;
+  }
+  function isConnected() {
+    return Boolean(nc) && !nc.isClosed();
+  }
+  function publishBytes(subject, payload, opts) {
+    const conn = requireConnection();
+    (async () => {
+      const nats = await importNats();
+      conn.publish(subject, payload, { headers: toNatsHeaders(nats, _optionalChain([opts, 'optionalAccess', _4 => _4.headers])) });
+    })().catch((e) => emitStatus({ status: "error", data: e }));
+  }
+  function publishString(subject, payload, opts) {
+    ;
+    (async () => {
+      const nats = await importNats();
+      const sc = nats.StringCodec();
+      publishBytes(subject, sc.encode(payload), opts);
+    })().catch((e) => emitStatus({ status: "error", data: e }));
+  }
+  function publishJson(subject, payload, opts) {
+    ;
+    (async () => {
+      const nats = await importNats();
+      const jc = nats.JSONCodec();
+      publishBytes(subject, jc.encode(payload), opts);
+    })().catch((e) => emitStatus({ status: "error", data: e }));
+  }
+  async function requestBytes(subject, payload, opts) {
+    const conn = requireConnection();
+    const nats = await importNats();
+    const msg = await conn.request(subject, payload, {
+      timeout: _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _5 => _5.timeoutMs]), () => ( 2e3)),
+      headers: toNatsHeaders(nats, _optionalChain([opts, 'optionalAccess', _6 => _6.headers]))
+    });
+    return msg;
+  }
+  async function requestString(subject, payload, opts) {
+    const nats = await importNats();
+    const sc = nats.StringCodec();
+    const msg = await requestBytes(subject, sc.encode(payload), opts);
+    return sc.decode(msg.data);
+  }
+  async function requestJson(subject, payload, opts) {
+    const nats = await importNats();
+    const reqCodec = nats.JSONCodec();
+    const resCodec = nats.JSONCodec();
+    const msg = await requestBytes(subject, reqCodec.encode(payload), opts);
+    return resCodec.decode(msg.data);
+  }
+  function subscribeBytes(subject, onMessage, opts) {
+    const conn = requireConnection();
+    const sub = conn.subscribe(subject, { queue: _optionalChain([opts, 'optionalAccess', _7 => _7.queue]) });
+    if (typeof _optionalChain([opts, 'optionalAccess', _8 => _8.max]) === "number") sub.unsubscribe(opts.max);
+    const abortController = new AbortController();
+    const signal = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _9 => _9.signal]), () => ( abortController.signal));
+    (async () => {
+      try {
+        for await (const msg of sub) {
+          if (signal.aborted) break;
+          await onMessage(msg);
+        }
+      } catch (e) {
+        emitStatus({ status: "error", data: e });
+      } finally {
+        try {
+          sub.unsubscribe();
+        } catch (e4) {
+        }
+      }
+    })().catch((e) => emitStatus({ status: "error", data: e }));
+    return {
+      subscription: sub,
+      unsubscribe() {
+        try {
+          abortController.abort();
+        } catch (e5) {
+        }
+        try {
+          sub.unsubscribe();
+        } catch (e6) {
+        }
+      }
+    };
+  }
+  function subscribeString(subject, onMessage, opts) {
+    return subscribeBytes(
+      subject,
+      async (msg) => {
+        const nats = await importNats();
+        const sc = nats.StringCodec();
+        await onMessage(sc.decode(msg.data), msg);
+      },
+      opts
+    );
+  }
+  function subscribeJson(subject, onMessage, opts) {
+    return subscribeBytes(
+      subject,
+      async (msg) => {
+        const nats = await importNats();
+        const jc = nats.JSONCodec();
+        await onMessage(jc.decode(msg.data), msg);
+      },
+      opts
+    );
+  }
+  async function subscribeJetStreamOrdered(onMessage, opts) {
+    const conn = requireConnection();
+    if (_optionalChain([opts, 'access', _10 => _10.signal, 'optionalAccess', _11 => _11.aborted])) {
+      return { unsubscribe() {
+      } };
+    }
+    const nats = await importNats();
+    if (_optionalChain([opts, 'access', _12 => _12.signal, 'optionalAccess', _13 => _13.aborted])) {
+      return { unsubscribe() {
+      } };
+    }
+    const inactiveThresholdNs = (_nullishCoalesce(opts.inactiveThresholdMs, () => ( 5 * 6e4))) * 1e6;
+    const js = conn.jetstream();
+    const consumer = await js.consumers.get(opts.streamName, {
+      filterSubjects: opts.filterSubject,
+      deliver_policy: nats.DeliverPolicy.StartSequence,
+      opt_start_seq: _nullishCoalesce(opts.optStartSeq, () => ( 0)),
+      inactive_threshold: inactiveThresholdNs
+    });
+    const iterRef = { current: null };
+    let closed = false;
+    const onAbort = () => {
+      void teardown();
+    };
+    _optionalChain([opts, 'access', _14 => _14.signal, 'optionalAccess', _15 => _15.addEventListener, 'call', _16 => _16("abort", onAbort, { once: true })]);
+    async function teardown() {
+      if (closed) return;
+      closed = true;
+      _optionalChain([opts, 'access', _17 => _17.signal, 'optionalAccess', _18 => _18.removeEventListener, 'call', _19 => _19("abort", onAbort)]);
+      const iter = iterRef.current;
+      iterRef.current = null;
+      if (iter) {
+        try {
+          await iter.close();
+        } catch (e7) {
+        }
+      }
+    }
+    if (_optionalChain([opts, 'access', _20 => _20.signal, 'optionalAccess', _21 => _21.aborted])) {
+      void teardown();
+      return { unsubscribe() {
+      } };
+    }
+    ;
+    (async () => {
+      try {
+        const iter = await consumer.consume();
+        if (closed) {
+          try {
+            await iter.close();
+          } catch (e8) {
+          }
+          return;
+        }
+        iterRef.current = iter;
+        for await (const msg of iter) {
+          if (closed) break;
+          try {
+            await onMessage(msg);
+          } catch (e) {
+            emitStatus({ status: "error", data: e });
+          }
+        }
+      } catch (e) {
+        if (!closed) emitStatus({ status: "error", data: e });
+      }
+    })().catch((e) => emitStatus({ status: "error", data: e }));
+    return {
+      unsubscribe() {
+        void teardown();
+      }
+    };
+  }
+  function onStatus(listener) {
+    statusListeners.add(listener);
+    return () => statusListeners.delete(listener);
+  }
+  return {
+    connect,
+    close,
+    isConnected,
+    publishBytes,
+    publishString,
+    publishJson,
+    requestBytes,
+    requestString,
+    requestJson,
+    subscribeBytes,
+    subscribeString,
+    subscribeJson,
+    subscribeJetStreamOrdered,
+    onStatus
+  };
+}
+
+// src/nats/shared-connection.ts
+var NATS_DEFAULTS = {
+  SHARED_CLOSE_DELAY_MS: 3e3,
+  CONNECT_TIMEOUT_MS: 1e4,
+  PING_INTERVAL_MS: 3e4,
+  MAX_PING_OUT: 3,
+  RETRY_INITIAL_DELAY_MS: 1e3,
+  RETRY_MAX_DELAY_MS: 3e4,
+  RETRY_MULTIPLIER: 2
+};
+var shared = null;
+function getSharedConnection() {
+  return shared;
+}
+function acquireClient(url, opts) {
+  if (_optionalChain([shared, 'optionalAccess', _22 => _22.wsUrl]) !== url) {
+    if (shared) {
+      if (shared.closeTimer) clearTimeout(shared.closeTimer);
+      const old = shared;
+      shared = null;
+      void old.client.close().catch(() => {
+      });
+    }
+    const {
+      name = "openframe-frontend",
+      user = "machine",
+      pass = "",
+      connectTimeoutMs = NATS_DEFAULTS.CONNECT_TIMEOUT_MS,
+      pingIntervalMs = NATS_DEFAULTS.PING_INTERVAL_MS,
+      maxPingOut = NATS_DEFAULTS.MAX_PING_OUT
+    } = _nullishCoalesce(opts, () => ( {}));
+    const client = createNatsClient({
+      servers: url,
+      name,
+      user,
+      pass,
+      connectTimeoutMs,
+      reconnect: false,
+      pingIntervalMs,
+      maxPingOut
+    });
+    shared = {
+      wsUrl: url,
+      client,
+      connectPromise: null,
+      refCount: 0,
+      closeTimer: null,
+      retryTimer: null,
+      retryOwner: null
+    };
+  }
+  shared.refCount += 1;
+  if (shared.closeTimer) {
+    clearTimeout(shared.closeTimer);
+    shared.closeTimer = null;
+  }
+  return shared;
+}
+function releaseClient(url, opts) {
+  if (!shared || shared.wsUrl !== url) return;
+  shared.refCount = Math.max(0, shared.refCount - 1);
+  if (shared.refCount > 0) return;
+  const delay = _nullishCoalesce(_optionalChain([opts, 'optionalAccess', _23 => _23.delayMs]), () => ( NATS_DEFAULTS.SHARED_CLOSE_DELAY_MS));
+  shared.closeTimer = setTimeout(() => {
+    const s = shared;
+    shared = null;
+    if (s) {
+      if (s.retryTimer) {
+        clearTimeout(s.retryTimer);
+        s.retryTimer = null;
+      }
+      void s.client.close().catch(() => {
+      });
+    }
+  }, delay);
+}
+function getSharedConnectionFor(url) {
+  if (!url) return null;
+  return shared && shared.wsUrl === url ? shared : null;
+}
+var defaultShouldRetryOn = (status) => status === "closed" || status === "disconnected";
+function startConnectionLifecycle(options) {
+  const { conn, wsUrl } = options;
+  const ownerToken = {};
+  if (!conn.retryOwner) conn.retryOwner = ownerToken;
+  let closed = false;
+  let retryAttempt = 0;
+  function emitSynthetic(status) {
+    if (closed) return;
+    _optionalChain([options, 'access', _24 => _24.onStatusChange, 'optionalCall', _25 => _25(status, { status })]);
+    if (status === "connected") {
+      retryAttempt = 0;
+    }
+  }
+  function scheduleRetry() {
+    if (closed) return;
+    if (getSharedConnectionFor(wsUrl) !== conn) return;
+    if (!conn.retryOwner) conn.retryOwner = ownerToken;
+    if (conn.retryOwner !== ownerToken) return;
+    if (conn.retryTimer) {
+      clearTimeout(conn.retryTimer);
+      conn.retryTimer = null;
+    }
+    const cfg = _nullishCoalesce(options.backoff, () => ( {}));
+    const fastRetries = _nullishCoalesce(cfg.fastRetries, () => ( 0));
+    const fastDelay = _nullishCoalesce(cfg.fastRetryDelayMs, () => ( NATS_DEFAULTS.RETRY_INITIAL_DELAY_MS));
+    const baseDelay = _nullishCoalesce(cfg.initialDelayMs, () => ( NATS_DEFAULTS.RETRY_INITIAL_DELAY_MS));
+    const maxDelay = _nullishCoalesce(cfg.maxDelayMs, () => ( NATS_DEFAULTS.RETRY_MAX_DELAY_MS));
+    const multiplier = _nullishCoalesce(cfg.multiplier, () => ( NATS_DEFAULTS.RETRY_MULTIPLIER));
+    const delay = retryAttempt < fastRetries ? fastDelay : Math.min(baseDelay * multiplier ** (retryAttempt - fastRetries), maxDelay);
+    const jitteredDelay = delay * (0.5 + Math.random() * 0.5);
+    retryAttempt++;
+    conn.retryTimer = setTimeout(async () => {
+      conn.retryTimer = null;
+      if (closed) return;
+      if (getSharedConnectionFor(wsUrl) !== conn) return;
+      try {
+        await _optionalChain([options, 'access', _26 => _26.onBeforeReconnect, 'optionalCall', _27 => _27()]);
+      } catch (e9) {
+      }
+      if (closed) return;
+      if (getSharedConnectionFor(wsUrl) !== conn) return;
+      const freshUrl = options.getFreshUrl();
+      if (freshUrl !== wsUrl) return;
+      try {
+        conn.connectPromise = null;
+        conn.connectPromise = conn.client.connect();
+        await conn.connectPromise;
+        if (!closed && getSharedConnectionFor(wsUrl) === conn) {
+          retryAttempt = 0;
+        }
+      } catch (e10) {
+        conn.connectPromise = null;
+        if (!closed && getSharedConnectionFor(wsUrl) === conn) {
+          scheduleRetry();
+        }
+      }
+    }, jitteredDelay);
+  }
+  const shouldRetryOn = _nullishCoalesce(options.shouldRetryOn, () => ( defaultShouldRetryOn));
+  const unsubStatus = conn.client.onStatus((evt) => {
+    if (closed) return;
+    _optionalChain([options, 'access', _28 => _28.onStatusChange, 'optionalCall', _29 => _29(evt.status, evt)]);
+    if (evt.status === "connected") {
+      retryAttempt = 0;
+    }
+    if (shouldRetryOn(evt.status)) {
+      scheduleRetry();
+    }
+  });
+  if (conn.client.isConnected()) {
+    emitSynthetic("connected");
+  }
+  void (async () => {
+    try {
+      conn.connectPromise || (conn.connectPromise = conn.client.connect());
+      await conn.connectPromise;
+    } catch (e11) {
+      conn.connectPromise = null;
+      if (closed) return;
+      emitSynthetic("disconnected");
+      scheduleRetry();
+    }
+  })();
+  return {
+    stop() {
+      closed = true;
+      unsubStatus();
+      if (conn.retryTimer) {
+        clearTimeout(conn.retryTimer);
+        conn.retryTimer = null;
+      }
+      if (conn.retryOwner === ownerToken) {
+        conn.retryOwner = null;
+      }
+    }
+  };
+}
+
+// src/nats/nats-provider.tsx
+var _react = require('react'); var React = _interopRequireWildcard(_react); var React2 = _interopRequireWildcard(_react);
+var _jsxruntime = require('react/jsx-runtime');
+var NatsContext = React.createContext(null);
+function NatsProvider({
+  children,
+  getWsUrl,
+  onBeforeReconnect,
+  clientConfig,
+  reconnectionBackoff,
+  urlRevision
+}) {
+  const [client, setClient] = React.useState(null);
+  const [status, setStatus] = React.useState("closed");
+  const [reconnectionCount, setReconnectionCount] = React.useState(0);
+  const getWsUrlRef = React.useRef(getWsUrl);
+  React.useEffect(() => {
+    getWsUrlRef.current = getWsUrl;
+  }, [getWsUrl]);
+  const onBeforeReconnectRef = React.useRef(onBeforeReconnect);
+  React.useEffect(() => {
+    onBeforeReconnectRef.current = onBeforeReconnect;
+  }, [onBeforeReconnect]);
+  const reconnectionBackoffRef = React.useRef(reconnectionBackoff);
+  React.useEffect(() => {
+    reconnectionBackoffRef.current = reconnectionBackoff;
+  }, [reconnectionBackoff]);
+  const clientConfigRef = React.useRef(clientConfig);
+  React.useEffect(() => {
+    clientConfigRef.current = clientConfig;
+  }, [clientConfig]);
+  const heldUrlRef = React.useRef(null);
+  const hadConnectionBeforeRef = React.useRef(false);
+  React.useEffect(() => {
+    const wsUrl = getWsUrlRef.current();
+    if (!wsUrl) {
+      if (heldUrlRef.current) {
+        releaseClient(heldUrlRef.current);
+        heldUrlRef.current = null;
+        setClient(null);
+        setStatus("closed");
+      }
+      return;
+    }
+    if (heldUrlRef.current && heldUrlRef.current !== wsUrl) {
+      releaseClient(heldUrlRef.current);
+      heldUrlRef.current = null;
+    }
+    const conn = acquireClient(wsUrl, clientConfigRef.current);
+    heldUrlRef.current = wsUrl;
+    setClient(conn.client);
+    setStatus(conn.client.isConnected() ? "connected" : "connecting");
+    const lifecycle = startConnectionLifecycle({
+      conn,
+      wsUrl,
+      onBeforeReconnect: () => _optionalChain([onBeforeReconnectRef, 'access', _30 => _30.current, 'optionalCall', _31 => _31()]),
+      backoff: reconnectionBackoffRef.current,
+      getFreshUrl: () => getWsUrlRef.current(),
+      onStatusChange: (newStatus) => {
+        setStatus(newStatus);
+        if (newStatus === "connected") {
+          if (hadConnectionBeforeRef.current) {
+            setReconnectionCount((c) => c + 1);
+          }
+          hadConnectionBeforeRef.current = true;
+        }
+      }
+    });
+    return () => {
+      lifecycle.stop();
+      if (heldUrlRef.current) {
+        releaseClient(heldUrlRef.current);
+        heldUrlRef.current = null;
+      }
+      setClient(null);
+      setStatus("closed");
+    };
+  }, [urlRevision]);
+  const value = React.useMemo(
+    () => ({
+      client,
+      status,
+      isReady: status === "connected" && client !== null,
+      reconnectionCount
+    }),
+    [client, status, reconnectionCount]
+  );
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, NatsContext.Provider, { value, children });
+}
+function useNats() {
+  const ctx = React.useContext(NatsContext);
+  if (!ctx) throw new Error("useNats must be used inside <NatsProvider>");
+  return ctx;
+}
+function useOptionalNats() {
+  return React.useContext(NatsContext);
+}
+
+// src/nats/use-nats-subscription.ts
+
+function useNatsSubscription(subject, onMessage, options) {
+  const nats = useOptionalNats();
+  const handlerRef = React2.useRef(onMessage);
+  React2.useEffect(() => {
+    handlerRef.current = onMessage;
+  }, [onMessage]);
+  const [isSubscribed, setIsSubscribed] = React2.useState(false);
+  const enabled = _optionalChain([options, 'optionalAccess', _32 => _32.enabled]) !== false;
+  const queue = _optionalChain([options, 'optionalAccess', _33 => _33.queue]);
+  const max = _optionalChain([options, 'optionalAccess', _34 => _34.max]);
+  const reconnectionCount = _nullishCoalesce(_optionalChain([nats, 'optionalAccess', _35 => _35.reconnectionCount]), () => ( 0));
+  const isReady = !!_optionalChain([nats, 'optionalAccess', _36 => _36.isReady]);
+  const client = _nullishCoalesce(_optionalChain([nats, 'optionalAccess', _37 => _37.client]), () => ( null));
+  React2.useEffect(() => {
+    if (!client || !isReady || !subject || !enabled) {
+      setIsSubscribed(false);
+      return;
+    }
+    const sub = client.subscribeBytes(
+      subject,
+      (msg) => handlerRef.current(msg),
+      { queue, max }
+    );
+    setIsSubscribed(true);
+    return () => {
+      setIsSubscribed(false);
+      try {
+        sub.unsubscribe();
+      } catch (e12) {
+      }
+    };
+  }, [client, isReady, subject, enabled, queue, max, reconnectionCount]);
+  return { isSubscribed, isReady };
+}
+function useNatsJsonSubscription(subject, onPayload, options) {
+  const handlerRef = React2.useRef(onPayload);
+  React2.useEffect(() => {
+    handlerRef.current = onPayload;
+  }, [onPayload]);
+  const decoderRef = React2.useRef(null);
+  if (!decoderRef.current && typeof TextDecoder !== "undefined") {
+    decoderRef.current = new TextDecoder();
+  }
+  const wrapped = React2.useCallback(async (msg) => {
+    const decoder = decoderRef.current;
+    if (!decoder) return;
+    try {
+      const parsed = JSON.parse(decoder.decode(msg.data));
+      await handlerRef.current(parsed, msg);
+    } catch (e13) {
+    }
+  }, []);
+  return useNatsSubscription(subject, wrapped, options);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.createNatsClient = createNatsClient; exports.NATS_DEFAULTS = NATS_DEFAULTS; exports.getSharedConnection = getSharedConnection; exports.acquireClient = acquireClient; exports.releaseClient = releaseClient; exports.getSharedConnectionFor = getSharedConnectionFor; exports.startConnectionLifecycle = startConnectionLifecycle; exports.NatsProvider = NatsProvider; exports.useNats = useNats; exports.useOptionalNats = useOptionalNats; exports.useNatsSubscription = useNatsSubscription; exports.useNatsJsonSubscription = useNatsJsonSubscription;
+//# sourceMappingURL=chunk-OZ3GH6OQ.cjs.map