@stacksjs/stx 0.2.95 → 0.2.96

package/dist/composables/use-timer.js

@@ -1,2 +1,183 @@
-// @bun
-import"../chunk-xv34zbp4.js";function K(D,G=250){let j=null,q=null,z=(...B)=>{if(q=B,j!==null)clearTimeout(j);j=setTimeout(()=>{j=null,q=null,D(...B)},G)};if(z.cancel=()=>{if(j!==null)clearTimeout(j),j=null,q=null},z.flush=()=>{if(j!==null&&q!==null){clearTimeout(j),j=null;let B=q;q=null,D(...B)}},z.pending=()=>j!==null,typeof globalThis.onDestroy==="function")globalThis.onDestroy(z.cancel);return z}function L(D,G=250){let j=D(),q=new Set,z=null;(()=>{if(z!==null)clearTimeout(z);z=setTimeout(()=>{z=null;let C=D();if(C!==j)j=C,q.forEach((E)=>E(j))},G)})();let F=()=>{if(z!==null)clearTimeout(z);q.clear()};if(typeof globalThis.onDestroy==="function")globalThis.onDestroy(F);return{get value(){return j},subscribe(C){return q.add(C),()=>{q.delete(C)}}}}function M(D,G=250){let j=null,q=0,z=(...B)=>{let F=Date.now(),C=G-(F-q);if(C<=0){if(j!==null)clearTimeout(j),j=null;q=F,D(...B)}else if(j===null)j=setTimeout(()=>{q=Date.now(),j=null,D(...B)},C)};if(z.cancel=()=>{if(j!==null)clearTimeout(j),j=null},typeof globalThis.onDestroy==="function")globalThis.onDestroy(z.cancel);return z}function N(D=1000,G={}){let j=0,q=null,z=!1,B=new Set,F=()=>{j++,B.forEach((H)=>H(j))},C=()=>{if(z)return;if(z=!0,q=setInterval(F,D),G.immediate)F()},E=()=>{if(!z)return;if(z=!1,q!==null)clearInterval(q),q=null},I=()=>{E(),j=0,B.forEach((H)=>H(j)),C()};C();let J=()=>{E(),B.clear()};if(typeof globalThis.onDestroy==="function")globalThis.onDestroy(J);return{get counter(){return j},pause:E,resume:C,reset:I,subscribe(H){return B.add(H),()=>{B.delete(H)}}}}function Q(D,G=1000){let j=null,q=!1,z=new Set,B=(E)=>{if(E!==q)q=E,z.forEach((I)=>I(q))},F=()=>{C(),B(!0),j=setTimeout(()=>{j=null,B(!1),D()},G)},C=()=>{if(j!==null)clearTimeout(j),j=null;B(!1)};if(F(),typeof globalThis.onDestroy==="function")globalThis.onDestroy(C);return{get isPending(){return q},start:F,stop:C,subscribe(E){return z.add(E),()=>{z.delete(E)}}}}export{Q as useTimeout,M as useThrottle,N as useInterval,L as useDebouncedValue,K as useDebounce};
+export function useDebounce(fn, delay = 250) {
+  let timer = null, lastArgs = null;
+  const debounced = (...args) => {
+    lastArgs = args;
+    if (timer !== null)
+      clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = null;
+      lastArgs = null;
+      fn(...args);
+    }, delay);
+  };
+  debounced.cancel = () => {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+      lastArgs = null;
+    }
+  };
+  debounced.flush = () => {
+    if (timer !== null && lastArgs !== null) {
+      clearTimeout(timer);
+      timer = null;
+      const args = lastArgs;
+      lastArgs = null;
+      fn(...args);
+    }
+  };
+  debounced.pending = () => timer !== null;
+  if (typeof globalThis.onDestroy === "function")
+    globalThis.onDestroy(debounced.cancel);
+  return debounced;
+}
+export function useDebouncedValue(getter, delay = 250) {
+  let current = getter();
+  const listeners = new Set;
+  let timer = null;
+  (() => {
+    if (timer !== null)
+      clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = null;
+      const next = getter();
+      if (next !== current) {
+        current = next;
+        listeners.forEach((fn) => fn(current));
+      }
+    }, delay);
+  })();
+  const cleanup = () => {
+    if (timer !== null)
+      clearTimeout(timer);
+    listeners.clear();
+  };
+  if (typeof globalThis.onDestroy === "function")
+    globalThis.onDestroy(cleanup);
+  return {
+    get value() {
+      return current;
+    },
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => {
+        listeners.delete(fn);
+      };
+    }
+  };
+}
+export function useThrottle(fn, limit = 250) {
+  let timer = null, lastRan = 0;
+  const throttled = (...args) => {
+    const now = Date.now(), remaining = limit - (now - lastRan);
+    if (remaining <= 0) {
+      if (timer !== null) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      lastRan = now;
+      fn(...args);
+    } else if (timer === null)
+      timer = setTimeout(() => {
+        lastRan = Date.now();
+        timer = null;
+        fn(...args);
+      }, remaining);
+  };
+  throttled.cancel = () => {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+  };
+  if (typeof globalThis.onDestroy === "function")
+    globalThis.onDestroy(throttled.cancel);
+  return throttled;
+}
+export function useInterval(interval = 1000, options = {}) {
+  let count = 0, id = null, running = !1;
+  const listeners = new Set, tick = () => {
+    count++;
+    listeners.forEach((fn) => fn(count));
+  }, resume = () => {
+    if (running)
+      return;
+    running = !0;
+    id = setInterval(tick, interval);
+    if (options.immediate)
+      tick();
+  }, pause = () => {
+    if (!running)
+      return;
+    running = !1;
+    if (id !== null) {
+      clearInterval(id);
+      id = null;
+    }
+  }, reset = () => {
+    pause();
+    count = 0;
+    listeners.forEach((fn) => fn(count));
+    resume();
+  };
+  resume();
+  const cleanup = () => {
+    pause();
+    listeners.clear();
+  };
+  if (typeof globalThis.onDestroy === "function")
+    globalThis.onDestroy(cleanup);
+  return {
+    get counter() {
+      return count;
+    },
+    pause,
+    resume,
+    reset,
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => {
+        listeners.delete(fn);
+      };
+    }
+  };
+}
+export function useTimeout(callback, delay = 1000) {
+  let timer = null, pending = !1;
+  const listeners = new Set, setPending = (v) => {
+    if (v !== pending) {
+      pending = v;
+      listeners.forEach((fn) => fn(pending));
+    }
+  }, start = () => {
+    stop();
+    setPending(!0);
+    timer = setTimeout(() => {
+      timer = null;
+      setPending(!1);
+      callback();
+    }, delay);
+  }, stop = () => {
+    if (timer !== null) {
+      clearTimeout(timer);
+      timer = null;
+    }
+    setPending(!1);
+  };
+  start();
+  if (typeof globalThis.onDestroy === "function")
+    globalThis.onDestroy(stop);
+  return {
+    get isPending() {
+      return pending;
+    },
+    start,
+    stop,
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => {
+        listeners.delete(fn);
+      };
+    }
+  };
+}

package/dist/composables/use-utilities.js

@@ -1,2 +1,176 @@
-// @bun
-import"../chunk-xv34zbp4.js";function K(H=!1){let E=H,k=new Set,q=()=>k.forEach((C)=>C(E));return[{get value(){return E},subscribe(C){return k.add(C),()=>{k.delete(C)}}},()=>{E=!E,q()},(C)=>{if(C!==E)E=C,q()}]}function M(H=0,E={}){let{min:k=-1/0,max:q=1/0}=E,z=C(H,k,q),G=new Set,I=()=>G.forEach((D)=>D(z));function C(D,b,J){return Math.min(J,Math.max(b,D))}return{get count(){return z},inc(D=1){z=C(z+D,k,q),I()},dec(D=1){z=C(z-D,k,q),I()},set(D){z=C(D,k,q),I()},reset(){z=C(H,k,q),I()},subscribe(D){return G.add(D),()=>{G.delete(D)}}}}function N(H,E){if(typeof window>"u")return{remove:()=>{}};let k=(z)=>{let G=typeof H==="string"?document.querySelector(H):H;if(!G)return;if(G===z.target||G.contains(z.target))return;E(z)};document.addEventListener("pointerdown",k,!0);let q=()=>{document.removeEventListener("pointerdown",k,!0)};if(typeof globalThis.onDestroy==="function")globalThis.onDestroy(q);return{remove:q}}function O(H){if(typeof window>"u")return{get isFocused(){return!1},focus:()=>{},blur:()=>{},subscribe:()=>()=>{}};let E=!1,k=new Set,q=()=>typeof H==="string"?document.querySelector(H):H,z=(b)=>{if(b!==E)E=b,k.forEach((J)=>J(E))},G=()=>z(!0),I=()=>z(!1),C=q();if(C)C.addEventListener("focus",G),C.addEventListener("blur",I),E=document.activeElement===C;let D=()=>{let b=q();if(b)b.removeEventListener("focus",G),b.removeEventListener("blur",I);k.clear()};if(typeof globalThis.onDestroy==="function")globalThis.onDestroy(D);return{get isFocused(){return E},focus(){let b=q();if(b&&typeof b.focus==="function")b.focus()},blur(){let b=q();if(b&&typeof b.blur==="function")b.blur()},subscribe(b){return k.add(b),()=>{k.delete(b)}}}}function P(H,E={}){let k="idle",q=null,z=null,G=new Set,I=()=>{let D={state:k,data:q,error:z};G.forEach((b)=>b(D))},C=async(...D)=>{k="loading",z=null,I();try{return q=await H(...D),k="success",I(),q}catch(b){return z=b instanceof Error?b:Error(String(b)),k="error",I(),null}};if(E.immediate)C();return{get state(){return k},get isLoading(){return k==="loading"},get error(){return z},get data(){return q},execute:C,subscribe(D){return G.add(D),()=>{G.delete(D)}}}}export{K as useToggle,O as useFocus,M as useCounter,N as useClickOutside,P as useAsync};
+export function useToggle(initial = !1) {
+  let current = initial;
+  const listeners = new Set, notify = () => listeners.forEach((fn) => fn(current));
+  return [{
+    get value() {
+      return current;
+    },
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => {
+        listeners.delete(fn);
+      };
+    }
+  }, () => {
+    current = !current;
+    notify();
+  }, (v) => {
+    if (v !== current) {
+      current = v;
+      notify();
+    }
+  }];
+}
+export function useCounter(initial = 0, options = {}) {
+  const { min = -1 / 0, max = 1 / 0 } = options;
+  let current = clamp(initial, min, max);
+  const listeners = new Set, notify = () => listeners.forEach((fn) => fn(current));
+  function clamp(v, lo, hi) {
+    return Math.min(hi, Math.max(lo, v));
+  }
+  return {
+    get count() {
+      return current;
+    },
+    inc(step = 1) {
+      current = clamp(current + step, min, max);
+      notify();
+    },
+    dec(step = 1) {
+      current = clamp(current - step, min, max);
+      notify();
+    },
+    set(value) {
+      current = clamp(value, min, max);
+      notify();
+    },
+    reset() {
+      current = clamp(initial, min, max);
+      notify();
+    },
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => {
+        listeners.delete(fn);
+      };
+    }
+  };
+}
+export function useClickOutside(target, handler) {
+  if (typeof window > "u")
+    return { remove: () => {} };
+  const listener = (event) => {
+    const el = typeof target === "string" ? document.querySelector(target) : target;
+    if (!el)
+      return;
+    if (el === event.target || el.contains(event.target))
+      return;
+    handler(event);
+  };
+  document.addEventListener("pointerdown", listener, !0);
+  const remove = () => {
+    document.removeEventListener("pointerdown", listener, !0);
+  };
+  if (typeof globalThis.onDestroy === "function")
+    globalThis.onDestroy(remove);
+  return { remove };
+}
+export function useFocus(target) {
+  if (typeof window > "u")
+    return {
+      get isFocused() {
+        return !1;
+      },
+      focus: () => {},
+      blur: () => {},
+      subscribe: () => () => {}
+    };
+  let focused = !1;
+  const listeners = new Set, resolve = () => typeof target === "string" ? document.querySelector(target) : target, setFocused = (v) => {
+    if (v !== focused) {
+      focused = v;
+      listeners.forEach((fn) => fn(focused));
+    }
+  }, onFocus = () => setFocused(!0), onBlur = () => setFocused(!1), el = resolve();
+  if (el) {
+    el.addEventListener("focus", onFocus);
+    el.addEventListener("blur", onBlur);
+    focused = document.activeElement === el;
+  }
+  const remove = () => {
+    const el = resolve();
+    if (el) {
+      el.removeEventListener("focus", onFocus);
+      el.removeEventListener("blur", onBlur);
+    }
+    listeners.clear();
+  };
+  if (typeof globalThis.onDestroy === "function")
+    globalThis.onDestroy(remove);
+  return {
+    get isFocused() {
+      return focused;
+    },
+    focus() {
+      const el = resolve();
+      if (el && typeof el.focus === "function")
+        el.focus();
+    },
+    blur() {
+      const el = resolve();
+      if (el && typeof el.blur === "function")
+        el.blur();
+    },
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => {
+        listeners.delete(fn);
+      };
+    }
+  };
+}
+export function useAsync(fn, options = {}) {
+  let asyncState = "idle", data = null, error = null;
+  const listeners = new Set, notify = () => {
+    const snapshot = { state: asyncState, data, error };
+    listeners.forEach((fn) => fn(snapshot));
+  }, execute = async (...args) => {
+    asyncState = "loading";
+    error = null;
+    notify();
+    try {
+      data = await fn(...args);
+      asyncState = "success";
+      notify();
+      return data;
+    } catch (e) {
+      error = e instanceof Error ? e : Error(String(e));
+      asyncState = "error";
+      notify();
+      return null;
+    }
+  };
+  if (options.immediate)
+    execute();
+  return {
+    get state() {
+      return asyncState;
+    },
+    get isLoading() {
+      return asyncState === "loading";
+    },
+    get error() {
+      return error;
+    },
+    get data() {
+      return data;
+    },
+    execute,
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => {
+        listeners.delete(fn);
+      };
+    }
+  };
+}

package/dist/composables/use-wake-lock.js

@@ -1,2 +1,122 @@
-// @bun
-import"../chunk-xv34zbp4.js";function Q(){return typeof navigator<"u"&&"wakeLock"in navigator}function M(){let z=Q(),D=new Set,j={isSupported:z,isActive:!1,type:null,error:null},E=null,G=null;function H(){D.forEach((F)=>F(j))}function N(){j={...j,isActive:!1,type:null},E=null,H()}function J(){if(document.visibilityState==="visible"&&j.isActive===!1&&E===null);}async function K(){if(!z)return j={...j,error:Error("Wake Lock API not supported")},H(),!1;try{if(E=await navigator.wakeLock.request("screen"),E.addEventListener("release",N),!G)document.addEventListener("visibilitychange",J),G=()=>{document.removeEventListener("visibilitychange",J)};return j={...j,isActive:!0,type:"screen",error:null},H(),!0}catch(F){return j={...j,isActive:!1,error:F},H(),!1}}async function I(){if(E)await E.release(),E=null;j={...j,isActive:!1,type:null},H()}async function O(){if(j.isActive)return await I(),!1;else return K()}return{get:()=>j,subscribe:(F)=>{return D.add(F),F(j),()=>{if(D.delete(F),D.size===0)I(),G?.(),G=null}},request:K,release:I,toggle:O,isSupported:()=>z,isActive:()=>j.isActive}}function T(){let z=M();if(z.isSupported())z.request();if(typeof document<"u"){let D=async()=>{if(document.visibilityState==="visible"&&!z.isActive())await z.request()};document.addEventListener("visibilitychange",D);let j=z.subscribe;return{...z,subscribe:(E)=>{let G=j(E);return()=>{G(),document.removeEventListener("visibilitychange",D),z.release()}}}}return z}function U(z){let D=M();async function j(){let E=z();if(E&&!D.isActive())await D.request();else if(!E&&D.isActive())await D.release()}return{...D,check:j}}export{M as useWakeLock,U as useConditionalWakeLock,T as useAutoWakeLock,Q as isWakeLockSupported};
+export function isWakeLockSupported() {
+  return typeof navigator < "u" && "wakeLock" in navigator;
+}
+export function useWakeLock() {
+  const supported = isWakeLockSupported(), subscribers = new Set;
+  let state = {
+    isSupported: supported,
+    isActive: !1,
+    type: null,
+    error: null
+  }, wakeLock = null, cleanup = null;
+  function notify() {
+    subscribers.forEach((fn) => fn(state));
+  }
+  function handleRelease() {
+    state = { ...state, isActive: !1, type: null };
+    wakeLock = null;
+    notify();
+  }
+  function handleVisibilityChange() {
+    if (document.visibilityState === "visible" && state.isActive === !1 && wakeLock === null)
+      ;
+  }
+  async function request() {
+    if (!supported) {
+      state = { ...state, error: Error("Wake Lock API not supported") };
+      notify();
+      return !1;
+    }
+    try {
+      wakeLock = await navigator.wakeLock.request("screen");
+      wakeLock.addEventListener("release", handleRelease);
+      if (!cleanup) {
+        document.addEventListener("visibilitychange", handleVisibilityChange);
+        cleanup = () => {
+          document.removeEventListener("visibilitychange", handleVisibilityChange);
+        };
+      }
+      state = { ...state, isActive: !0, type: "screen", error: null };
+      notify();
+      return !0;
+    } catch (error) {
+      state = { ...state, isActive: !1, error };
+      notify();
+      return !1;
+    }
+  }
+  async function release() {
+    if (wakeLock) {
+      await wakeLock.release();
+      wakeLock = null;
+    }
+    state = { ...state, isActive: !1, type: null };
+    notify();
+  }
+  async function toggle() {
+    if (state.isActive) {
+      await release();
+      return !1;
+    } else
+      return request();
+  }
+  return {
+    get: () => state,
+    subscribe: (fn) => {
+      subscribers.add(fn);
+      fn(state);
+      return () => {
+        subscribers.delete(fn);
+        if (subscribers.size === 0) {
+          release();
+          cleanup?.();
+          cleanup = null;
+        }
+      };
+    },
+    request,
+    release,
+    toggle,
+    isSupported: () => supported,
+    isActive: () => state.isActive
+  };
+}
+export function useAutoWakeLock() {
+  const wakeLock = useWakeLock();
+  if (wakeLock.isSupported())
+    wakeLock.request();
+  if (typeof document < "u") {
+    const handleVisibility = async () => {
+      if (document.visibilityState === "visible" && !wakeLock.isActive())
+        await wakeLock.request();
+    };
+    document.addEventListener("visibilitychange", handleVisibility);
+    const originalSubscribe = wakeLock.subscribe;
+    return {
+      ...wakeLock,
+      subscribe: (fn) => {
+        const unsub = originalSubscribe(fn);
+        return () => {
+          unsub();
+          document.removeEventListener("visibilitychange", handleVisibility);
+          wakeLock.release();
+        };
+      }
+    };
+  }
+  return wakeLock;
+}
+export function useConditionalWakeLock(condition) {
+  const wakeLock = useWakeLock();
+  async function check() {
+    const shouldBeActive = condition();
+    if (shouldBeActive && !wakeLock.isActive())
+      await wakeLock.request();
+    else if (!shouldBeActive && wakeLock.isActive())
+      await wakeLock.release();
+  }
+  return {
+    ...wakeLock,
+    check
+  };
+}

package/dist/composables/use-websocket.js

@@ -1,2 +1,165 @@
-// @bun
-import"../chunk-xv34zbp4.js";function R(){return typeof window<"u"&&"WebSocket"in window}function T($,q={}){let{protocols:M,autoReconnect:J=!1,heartbeat:N=!1,immediate:O=!0,onOpen:W,onMessage:S,onClose:x,onError:D}=q,V=new Set,K=new Map,A={status:"closed",data:null,error:null,ws:null},P=0,Q=null,F=null,X=!1;function G(){V.forEach((j)=>j(A))}function U(j,z){let B=K.get(j);if(B)B.forEach((_)=>_(z))}function Y(){if(Q)clearInterval(Q),Q=null;if(F)clearTimeout(F),F=null}function H(j){if(!N)return;let z=typeof N==="object"?N:{message:"ping",interval:30000,pongTimeout:1e4};Y(),Q=setInterval(()=>{if(j.readyState===WebSocket.OPEN)j.send(z.message||"ping"),F=setTimeout(()=>{j.close()},z.pongTimeout||1e4)},z.interval||30000)}function I(){if(typeof J==="object")return{retries:J.retries??3,delay:J.delay??1000,maxDelay:J.maxDelay??1e4,onFailed:J.onFailed};return{retries:3,delay:1000,maxDelay:1e4,onFailed:void 0}}function Z(){if(!R())return;X=!1,A={...A,status:"connecting"},G();try{let j=new WebSocket($,M);A={...A,ws:j},j.onopen=(z)=>{A={...A,status:"open"},P=0,G(),H(j),U("open",z),W?.(z)},j.onmessage=(z)=>{if(N&&F)clearTimeout(F),F=null;let B;try{B=JSON.parse(z.data)}catch{B=z.data}A={...A,data:B},G(),U("message",z),S?.(z)},j.onclose=(z)=>{if(Y(),A={...A,status:"closed",ws:null},G(),U("close",z),x?.(z),J&&!X){let B=I();if(P<B.retries){let _=Math.min(B.delay*2**P,B.maxDelay);P++,setTimeout(Z,_)}else B.onFailed?.()}},j.onerror=(z)=>{A={...A,error:z},G(),U("error",z),D?.(z)}}catch(j){A={...A,status:"closed",error:j},G()}}function k(j){if(A.ws&&A.status==="open"){let z=typeof j==="object"&&!(j instanceof ArrayBuffer)&&!(j instanceof Blob)?JSON.stringify(j):j;return A.ws.send(z),!0}return!1}function E(j,z){if(X=!0,Y(),A.ws)A={...A,status:"closing"},G(),A.ws.close(j,z)}function L(j,z){if(!K.has(j))K.set(j,new Set);return K.get(j).add(z),()=>{K.get(j)?.delete(z)}}if(O)Z();return{get:()=>A,subscribe:(j)=>{return V.add(j),j(A),()=>{V.delete(j)}},send:k,open:Z,close:E,ws:()=>A.ws,on:L}}export{T as useWebSocket,R as isWebSocketSupported};
+export function isWebSocketSupported() {
+  return typeof window < "u" && "WebSocket" in window;
+}
+export function useWebSocket(url, options = {}) {
+  const {
+    protocols,
+    autoReconnect = !1,
+    heartbeat = !1,
+    immediate = !0,
+    onOpen,
+    onMessage,
+    onClose,
+    onError
+  } = options, subscribers = new Set, eventListeners = new Map;
+  let state = {
+    status: "closed",
+    data: null,
+    error: null,
+    ws: null
+  }, retryCount = 0, heartbeatInterval = null, pongTimeout = null, explicitlyClosed = !1;
+  function notify() {
+    subscribers.forEach((fn) => fn(state));
+  }
+  function emitEvent(type, event) {
+    const listeners = eventListeners.get(type);
+    if (listeners)
+      listeners.forEach((fn) => fn(event));
+  }
+  function resetHeartbeat() {
+    if (heartbeatInterval) {
+      clearInterval(heartbeatInterval);
+      heartbeatInterval = null;
+    }
+    if (pongTimeout) {
+      clearTimeout(pongTimeout);
+      pongTimeout = null;
+    }
+  }
+  function startHeartbeat(ws) {
+    if (!heartbeat)
+      return;
+    const config = typeof heartbeat === "object" ? heartbeat : { message: "ping", interval: 30000, pongTimeout: 1e4 };
+    resetHeartbeat();
+    heartbeatInterval = setInterval(() => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(config.message || "ping");
+        pongTimeout = setTimeout(() => {
+          ws.close();
+        }, config.pongTimeout || 1e4);
+      }
+    }, config.interval || 30000);
+  }
+  function getReconnectConfig() {
+    if (typeof autoReconnect === "object")
+      return {
+        retries: autoReconnect.retries ?? 3,
+        delay: autoReconnect.delay ?? 1000,
+        maxDelay: autoReconnect.maxDelay ?? 1e4,
+        onFailed: autoReconnect.onFailed
+      };
+    return { retries: 3, delay: 1000, maxDelay: 1e4, onFailed: void 0 };
+  }
+  function connect() {
+    if (!isWebSocketSupported())
+      return;
+    explicitlyClosed = !1;
+    state = { ...state, status: "connecting" };
+    notify();
+    try {
+      const ws = new WebSocket(url, protocols);
+      state = { ...state, ws };
+      ws.onopen = (event) => {
+        state = { ...state, status: "open" };
+        retryCount = 0;
+        notify();
+        startHeartbeat(ws);
+        emitEvent("open", event);
+        onOpen?.(event);
+      };
+      ws.onmessage = (event) => {
+        if (heartbeat && pongTimeout) {
+          clearTimeout(pongTimeout);
+          pongTimeout = null;
+        }
+        let parsedData;
+        try {
+          parsedData = JSON.parse(event.data);
+        } catch {
+          parsedData = event.data;
+        }
+        state = { ...state, data: parsedData };
+        notify();
+        emitEvent("message", event);
+        onMessage?.(event);
+      };
+      ws.onclose = (event) => {
+        resetHeartbeat();
+        state = { ...state, status: "closed", ws: null };
+        notify();
+        emitEvent("close", event);
+        onClose?.(event);
+        if (autoReconnect && !explicitlyClosed) {
+          const config = getReconnectConfig();
+          if (retryCount < config.retries) {
+            const delay = Math.min(config.delay * 2 ** retryCount, config.maxDelay);
+            retryCount++;
+            setTimeout(connect, delay);
+          } else
+            config.onFailed?.();
+        }
+      };
+      ws.onerror = (event) => {
+        state = { ...state, error: event };
+        notify();
+        emitEvent("error", event);
+        onError?.(event);
+      };
+    } catch (error) {
+      state = { ...state, status: "closed", error };
+      notify();
+    }
+  }
+  function send(data) {
+    if (state.ws && state.status === "open") {
+      const message = typeof data === "object" && !(data instanceof ArrayBuffer) && !(data instanceof Blob) ? JSON.stringify(data) : data;
+      state.ws.send(message);
+      return !0;
+    }
+    return !1;
+  }
+  function close(code, reason) {
+    explicitlyClosed = !0;
+    resetHeartbeat();
+    if (state.ws) {
+      state = { ...state, status: "closing" };
+      notify();
+      state.ws.close(code, reason);
+    }
+  }
+  function on(event, callback) {
+    if (!eventListeners.has(event))
+      eventListeners.set(event, new Set);
+    eventListeners.get(event).add(callback);
+    return () => {
+      eventListeners.get(event)?.delete(callback);
+    };
+  }
+  if (immediate)
+    connect();
+  return {
+    get: () => state,
+    subscribe: (fn) => {
+      subscribers.add(fn);
+      fn(state);
+      return () => {
+        subscribers.delete(fn);
+      };
+    },
+    send,
+    open: connect,
+    close,
+    ws: () => state.ws,
+    on
+  };
+}