@stacksjs/stx 0.2.95 → 0.2.96

package/dist/composables/use-event-source.js

@@ -1,2 +1,166 @@
-// @bun
-import"../chunk-xv34zbp4.js";function O(){return typeof window<"u"&&"EventSource"in window}function k(T,G={}){let{withCredentials:I=!1,autoReconnect:B=!0,immediate:Z=!0,events:Y=[],onOpen:_,onMessage:$,onError:h}=G,U=new Set,K=new Map,q={status:"closed",data:null,event:null,lastEventId:null,error:null},A=null,Q=0,V=!1;function H(){U.forEach((j)=>j(q))}function W(j,z){let F=K.get(j);if(F)F.forEach((P)=>P(z))}function w(){if(typeof B==="object")return{retries:B.retries??3,delay:B.delay??1000,onFailed:B.onFailed};return{retries:3,delay:1000,onFailed:void 0}}function X(){if(!O())return;V=!1,q={...q,status:"connecting"},H();try{A=new EventSource(T.toString(),{withCredentials:I}),A.onopen=(j)=>{q={...q,status:"open"},Q=0,H(),_?.(j)},A.onmessage=(j)=>{let z;try{z=JSON.parse(j.data)}catch{z=j.data}q={...q,data:z,event:"message",lastEventId:j.lastEventId||null},H(),W("message",j),$?.(j)},A.onerror=(j)=>{if(q={...q,status:"error",error:j},H(),h?.(j),A?.readyState===EventSource.CLOSED){if(q={...q,status:"closed"},H(),B&&!V){let z=w();if(Q<z.retries)Q++,setTimeout(X,z.delay*Q);else z.onFailed?.()}}};for(let j of Y)A.addEventListener(j,(z)=>{let F=z,P;try{P=JSON.parse(F.data)}catch{P=F.data}q={...q,data:P,event:j,lastEventId:F.lastEventId||null},H(),W(j,F)})}catch(j){q={...q,status:"error",error:j},H()}}function J(){if(V=!0,A)A.close(),A=null,q={...q,status:"closed"},H()}function M(j,z){if(!K.has(j)){if(K.set(j,new Set),A&&!Y.includes(j))A.addEventListener(j,(F)=>{W(j,F)})}return K.get(j).add(z),()=>{K.get(j)?.delete(z)}}if(Z)X();return{get:()=>q,subscribe:(j)=>{return U.add(j),j(q),()=>{U.delete(j)}},open:X,close:J,eventSource:()=>A,on:M}}function x(T){let G=k(T);return{data:{get:()=>G.get().data,subscribe:(I)=>{return G.subscribe((B)=>I(B.data))}},status:{get:()=>G.get().status,subscribe:(I)=>{return G.subscribe((B)=>I(B.status))}},close:G.close,open:G.open}}export{x as useSSE,k as useEventSource,O as isEventSourceSupported};
+export function isEventSourceSupported() {
+  return typeof window < "u" && "EventSource" in window;
+}
+export function useEventSource(url, options = {}) {
+  const {
+    withCredentials = !1,
+    autoReconnect = !0,
+    immediate = !0,
+    events = [],
+    onOpen,
+    onMessage,
+    onError
+  } = options, subscribers = new Set, eventListeners = new Map;
+  let state = {
+    status: "closed",
+    data: null,
+    event: null,
+    lastEventId: null,
+    error: null
+  }, eventSource = null, retryCount = 0, explicitlyClosed = !1;
+  function notify() {
+    subscribers.forEach((fn) => fn(state));
+  }
+  function emitEvent(eventName, event) {
+    const listeners = eventListeners.get(eventName);
+    if (listeners)
+      listeners.forEach((fn) => fn(event));
+  }
+  function getReconnectConfig() {
+    if (typeof autoReconnect === "object")
+      return {
+        retries: autoReconnect.retries ?? 3,
+        delay: autoReconnect.delay ?? 1000,
+        onFailed: autoReconnect.onFailed
+      };
+    return { retries: 3, delay: 1000, onFailed: void 0 };
+  }
+  function connect() {
+    if (!isEventSourceSupported())
+      return;
+    explicitlyClosed = !1;
+    state = { ...state, status: "connecting" };
+    notify();
+    try {
+      eventSource = new EventSource(url.toString(), { withCredentials });
+      eventSource.onopen = (event) => {
+        state = { ...state, status: "open" };
+        retryCount = 0;
+        notify();
+        onOpen?.(event);
+      };
+      eventSource.onmessage = (event) => {
+        let parsedData;
+        try {
+          parsedData = JSON.parse(event.data);
+        } catch {
+          parsedData = event.data;
+        }
+        state = {
+          ...state,
+          data: parsedData,
+          event: "message",
+          lastEventId: event.lastEventId || null
+        };
+        notify();
+        emitEvent("message", event);
+        onMessage?.(event);
+      };
+      eventSource.onerror = (event) => {
+        state = { ...state, status: "error", error: event };
+        notify();
+        onError?.(event);
+        if (eventSource?.readyState === EventSource.CLOSED) {
+          state = { ...state, status: "closed" };
+          notify();
+          if (autoReconnect && !explicitlyClosed) {
+            const config = getReconnectConfig();
+            if (retryCount < config.retries) {
+              retryCount++;
+              setTimeout(connect, config.delay * retryCount);
+            } else
+              config.onFailed?.();
+          }
+        }
+      };
+      for (const eventName of events)
+        eventSource.addEventListener(eventName, (event) => {
+          const messageEvent = event;
+          let parsedData;
+          try {
+            parsedData = JSON.parse(messageEvent.data);
+          } catch {
+            parsedData = messageEvent.data;
+          }
+          state = {
+            ...state,
+            data: parsedData,
+            event: eventName,
+            lastEventId: messageEvent.lastEventId || null
+          };
+          notify();
+          emitEvent(eventName, messageEvent);
+        });
+    } catch (error) {
+      state = { ...state, status: "error", error };
+      notify();
+    }
+  }
+  function close() {
+    explicitlyClosed = !0;
+    if (eventSource) {
+      eventSource.close();
+      eventSource = null;
+      state = { ...state, status: "closed" };
+      notify();
+    }
+  }
+  function on(eventName, callback) {
+    if (!eventListeners.has(eventName)) {
+      eventListeners.set(eventName, new Set);
+      if (eventSource && !events.includes(eventName))
+        eventSource.addEventListener(eventName, (event) => {
+          emitEvent(eventName, event);
+        });
+    }
+    eventListeners.get(eventName).add(callback);
+    return () => {
+      eventListeners.get(eventName)?.delete(callback);
+    };
+  }
+  if (immediate)
+    connect();
+  return {
+    get: () => state,
+    subscribe: (fn) => {
+      subscribers.add(fn);
+      fn(state);
+      return () => {
+        subscribers.delete(fn);
+      };
+    },
+    open: connect,
+    close,
+    eventSource: () => eventSource,
+    on
+  };
+}
+export function useSSE(url) {
+  const sse = useEventSource(url);
+  return {
+    data: {
+      get: () => sse.get().data,
+      subscribe: (fn) => {
+        return sse.subscribe((state) => fn(state.data));
+      }
+    },
+    status: {
+      get: () => sse.get().status,
+      subscribe: (fn) => {
+        return sse.subscribe((state) => fn(state.status));
+      }
+    },
+    close: sse.close,
+    open: sse.open
+  };
+}

package/dist/composables/use-eye-dropper.js

@@ -1,2 +1,142 @@
-// @bun
-import"../chunk-xv34zbp4.js";function Q(){return typeof window<"u"&&"EyeDropper"in window}function U(M={}){let{onPick:G,onAbort:L,onError:B}=M,I=Q(),z=new Set,q={isSupported:I,isOpen:!1,sRGBHex:null,error:null},K=null;function J(){z.forEach((j)=>j(q))}async function O(){if(!I||!window.EyeDropper){let j=Error("EyeDropper API not supported");return q={...q,error:j},J(),B?.(j),null}K?.abort(),K=new AbortController,q={...q,isOpen:!0,error:null},J();try{let N=await new window.EyeDropper().open({signal:K.signal});return q={...q,isOpen:!1,sRGBHex:N.sRGBHex},J(),G?.(N.sRGBHex),N.sRGBHex}catch(j){if(q={...q,isOpen:!1},j.name==="AbortError")return L?.(),J(),null;return q={...q,error:j},J(),B?.(j),null}}return{get:()=>q,subscribe:(j)=>{return z.add(j),j(q),()=>{if(z.delete(j),z.size===0)K?.abort()}},open:O,isSupported:()=>I}}async function W(){if(!Q()||!window.EyeDropper)return null;try{return(await new window.EyeDropper().open()).sRGBHex}catch{return null}}function V(M){let G=/^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(M);return G?{r:Number.parseInt(G[1],16),g:Number.parseInt(G[2],16),b:Number.parseInt(G[3],16)}:null}function X(M){let G=V(M);if(!G)return null;let L=G.r/255,B=G.g/255,I=G.b/255,z=Math.max(L,B,I),q=Math.min(L,B,I),K=(z+q)/2;if(z===q)return{h:0,s:0,l:Math.round(K*100)};let J=z-q,O=K>0.5?J/(2-z-q):J/(z+q),j=0;switch(z){case L:j=((B-I)/J+(B<I?6:0))/6;break;case B:j=((I-L)/J+2)/6;break;case I:j=((L-B)/J+4)/6;break}return{h:Math.round(j*360),s:Math.round(O*100),l:Math.round(K*100)}}function Y(M={}){let{maxHistory:G=20,onPick:L}=M,B=U({onPick:L}),I=new Set,z=[];function q(){let j={current:B.get().sRGBHex,history:z};I.forEach((N)=>N(j))}B.subscribe((j)=>{if(j.sRGBHex&&!z.includes(j.sRGBHex))z=[j.sRGBHex,...z].slice(0,G),q()});async function K(){return B.open()}function J(){z=[],q()}function O(j){z=z.filter((N)=>N!==j),q()}return{get:()=>({current:B.get().sRGBHex,history:z}),subscribe:(j)=>{return I.add(j),j({current:B.get().sRGBHex,history:z}),()=>{I.delete(j)}},pick:K,clearHistory:J,removeFromHistory:O,isSupported:B.isSupported}}export{U as useEyeDropper,Y as useColorHistory,W as pickColor,Q as isEyeDropperSupported,V as hexToRgb,X as hexToHsl};
+export function isEyeDropperSupported() {
+  return typeof window < "u" && "EyeDropper" in window;
+}
+export function useEyeDropper(options = {}) {
+  const { onPick, onAbort, onError } = options, supported = isEyeDropperSupported(), subscribers = new Set;
+  let state = {
+    isSupported: supported,
+    isOpen: !1,
+    sRGBHex: null,
+    error: null
+  }, abortController = null;
+  function notify() {
+    subscribers.forEach((fn) => fn(state));
+  }
+  async function open() {
+    if (!supported || !window.EyeDropper) {
+      const error = Error("EyeDropper API not supported");
+      state = { ...state, error };
+      notify();
+      onError?.(error);
+      return null;
+    }
+    abortController?.abort();
+    abortController = new AbortController;
+    state = { ...state, isOpen: !0, error: null };
+    notify();
+    try {
+      const result = await new window.EyeDropper().open({ signal: abortController.signal });
+      state = { ...state, isOpen: !1, sRGBHex: result.sRGBHex };
+      notify();
+      onPick?.(result.sRGBHex);
+      return result.sRGBHex;
+    } catch (error) {
+      state = { ...state, isOpen: !1 };
+      if (error.name === "AbortError") {
+        onAbort?.();
+        notify();
+        return null;
+      }
+      state = { ...state, error };
+      notify();
+      onError?.(error);
+      return null;
+    }
+  }
+  return {
+    get: () => state,
+    subscribe: (fn) => {
+      subscribers.add(fn);
+      fn(state);
+      return () => {
+        subscribers.delete(fn);
+        if (subscribers.size === 0)
+          abortController?.abort();
+      };
+    },
+    open,
+    isSupported: () => supported
+  };
+}
+export async function pickColor() {
+  if (!isEyeDropperSupported() || !window.EyeDropper)
+    return null;
+  try {
+    return (await new window.EyeDropper().open()).sRGBHex;
+  } catch {
+    return null;
+  }
+}
+export function hexToRgb(hex) {
+  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+  return result ? {
+    r: Number.parseInt(result[1], 16),
+    g: Number.parseInt(result[2], 16),
+    b: Number.parseInt(result[3], 16)
+  } : null;
+}
+export function hexToHsl(hex) {
+  const rgb = hexToRgb(hex);
+  if (!rgb)
+    return null;
+  const r = rgb.r / 255, g = rgb.g / 255, b = rgb.b / 255, max = Math.max(r, g, b), min = Math.min(r, g, b), l = (max + min) / 2;
+  if (max === min)
+    return { h: 0, s: 0, l: Math.round(l * 100) };
+  const d = max - min, s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+  let h = 0;
+  switch (max) {
+    case r:
+      h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+      break;
+    case g:
+      h = ((b - r) / d + 2) / 6;
+      break;
+    case b:
+      h = ((r - g) / d + 4) / 6;
+      break;
+  }
+  return {
+    h: Math.round(h * 360),
+    s: Math.round(s * 100),
+    l: Math.round(l * 100)
+  };
+}
+export function useColorHistory(options = {}) {
+  const { maxHistory = 20, onPick } = options, eyeDropper = useEyeDropper({ onPick }), subscribers = new Set;
+  let history = [];
+  function notify() {
+    const state = { current: eyeDropper.get().sRGBHex, history };
+    subscribers.forEach((fn) => fn(state));
+  }
+  eyeDropper.subscribe((state) => {
+    if (state.sRGBHex && !history.includes(state.sRGBHex)) {
+      history = [state.sRGBHex, ...history].slice(0, maxHistory);
+      notify();
+    }
+  });
+  async function pick() {
+    return eyeDropper.open();
+  }
+  function clearHistory() {
+    history = [];
+    notify();
+  }
+  function removeFromHistory(color) {
+    history = history.filter((c) => c !== color);
+    notify();
+  }
+  return {
+    get: () => ({ current: eyeDropper.get().sRGBHex, history }),
+    subscribe: (fn) => {
+      subscribers.add(fn);
+      fn({ current: eyeDropper.get().sRGBHex, history });
+      return () => {
+        subscribers.delete(fn);
+      };
+    },
+    pick,
+    clearHistory,
+    removeFromHistory,
+    isSupported: eyeDropper.isSupported
+  };
+}

package/dist/composables/use-fetch.js

@@ -1,2 +1,223 @@
-// @bun
-import{dq as J}from"../chunk-q6zhd9yf.js";import"../chunk-xv34zbp4.js";var D=new Map;function i(j,M,N){let z=M?`${M.replace(/\/$/,"")}/${j.replace(/^\//,"")}`:j;if(N){let W=new URLSearchParams;for(let[_,X]of Object.entries(N))if(X!==void 0)W.append(_,String(X));let P=W.toString();if(P)z+=(z.includes("?")?"&":"?")+P}return z}function f(j,M={}){let{immediate:N=!0,transform:z,parseResponse:W=(G)=>G.json(),timeout:P=30000,retry:_=0,retryDelay:X=1000,key:$,cacheTime:Y=0,refetchOnFocus:I=!1,refetchInterval:H,initialData:S=null,baseURL:q,query:L,body:Q,...A}=M,E=J(S),K=J(!1),O=J(null),U=J(null),v=J(null),w=null,B=null,k=null,F=()=>{let G=typeof j==="function"?j():j;return i(G,q,L)},R=()=>$||F(),p=()=>{if(Y<=0)return null;let G=D.get(R());if(G&&Date.now()-G.timestamp<Y)return G.data;return null},y=(G)=>{if(Y>0)D.set(R(),{data:G,timestamp:Date.now()})},x=async(G=0)=>{let C=p();if(C!==null){E.set(C),K.set(!1),O.set(null);return}if(w)w.abort();w=new AbortController,K.set(!0),O.set(null);let m=setTimeout(()=>w?.abort(),P);try{let V;if(Q)if(typeof Q==="object"&&!(Q instanceof FormData)&&!(Q instanceof URLSearchParams))V=JSON.stringify(Q),A.headers={"Content-Type":"application/json",...A.headers};else V=Q;let Z=await fetch(F(),{...A,body:V,signal:w.signal});if(clearTimeout(m),U.set(Z.status),v.set(Z.statusText),!Z.ok)throw Error(`HTTP ${Z.status}: ${Z.statusText}`);let T=await W(Z);if(z)T=z(T);y(T),E.set(T),K.set(!1)}catch(V){if(clearTimeout(m),V instanceof Error&&V.name==="AbortError")return;if(G<_)return await new Promise((Z)=>setTimeout(Z,X)),x(G+1);O.set(V instanceof Error?V:Error(String(V))),K.set(!1)}},b=()=>{if(!I||typeof window>"u")return;B=()=>{if(document.visibilityState==="visible")x()},document.addEventListener("visibilitychange",B)},g=()=>{if(!H||typeof window>"u")return;k=setInterval(()=>void x(),H)};if(N)x(),b(),g();return{data:E,loading:K,error:O,status:U,statusText:v,refetch:()=>x(),execute:async()=>{await x(),b(),g()},abort:()=>{if(w)w.abort();if(B)document.removeEventListener("visibilitychange",B),B=null;if(k)clearInterval(k),k=null}}}function n(j,M={}){let{immediate:N=!0,transform:z,initialData:W=null,key:P,cacheTime:_=0}=M,X=J(W),$=J(!1),Y=J(null),I=J(null),H=J(null),S=()=>P||j.toString(),q=()=>{if(_<=0)return null;let A=D.get(S());if(A&&Date.now()-A.timestamp<_)return A.data;return null},L=(A)=>{if(_>0)D.set(S(),{data:A,timestamp:Date.now()})},Q=async()=>{let A=q();if(A!==null){X.set(A),$.set(!1),Y.set(null);return}$.set(!0),Y.set(null);try{let E=await j();if(z)E=z(E);L(E),X.set(E),$.set(!1)}catch(E){Y.set(E instanceof Error?E:Error(String(E))),$.set(!1)}};if(N)Q();return{data:X,loading:$,error:Y,status:I,statusText:H,refetch:Q,execute:Q,abort:()=>{}}}function h(j,M={}){let N,z=f(j,{...M,method:"POST",immediate:!1,get body(){return N}});return{execute:async(W)=>{return N=W,await z.execute(),z.data()},state:z}}function d(j){if(j)D.delete(j);else D.clear()}async function l(j,M){await f(j,{...M,immediate:!1}).execute()}export{h as usePost,f as useFetch,n as useAsyncData,l as prefetch,d as clearFetchCache};
+import { state } from "../signals-api.js";
+const fetchCache = new Map;
+function buildURL(url, baseURL, query) {
+  let fullURL = baseURL ? `${baseURL.replace(/\/$/, "")}/${url.replace(/^\//, "")}` : url;
+  if (query) {
+    const params = new URLSearchParams;
+    for (const [key, value] of Object.entries(query))
+      if (value !== void 0)
+        params.append(key, String(value));
+    const queryString = params.toString();
+    if (queryString)
+      fullURL += (fullURL.includes("?") ? "&" : "?") + queryString;
+  }
+  return fullURL;
+}
+export function useFetch(url, options = {}) {
+  const {
+    immediate = !0,
+    transform,
+    parseResponse = (r) => r.json(),
+    timeout = 30000,
+    retry = 0,
+    retryDelay = 1000,
+    key,
+    cacheTime = 0,
+    refetchOnFocus = !1,
+    refetchInterval,
+    initialData = null,
+    baseURL,
+    query,
+    body,
+    ...fetchOptions
+  } = options, data = state(initialData), loading = state(!1), error = state(null), status = state(null), statusText = state(null);
+  let abortController = null, focusHandler = null, intervalId = null;
+  const getURL = () => {
+    const rawURL = typeof url === "function" ? url() : url;
+    return buildURL(rawURL, baseURL, query);
+  }, getCacheKey = () => key || getURL(), getFromCache = () => {
+    if (cacheTime <= 0)
+      return null;
+    const cached = fetchCache.get(getCacheKey());
+    if (cached && Date.now() - cached.timestamp < cacheTime)
+      return cached.data;
+    return null;
+  }, setCache = (value) => {
+    if (cacheTime > 0)
+      fetchCache.set(getCacheKey(), { data: value, timestamp: Date.now() });
+  }, doFetch = async (attempt = 0) => {
+    const cached = getFromCache();
+    if (cached !== null) {
+      data.set(cached);
+      loading.set(!1);
+      error.set(null);
+      return;
+    }
+    if (abortController)
+      abortController.abort();
+    abortController = new AbortController;
+    loading.set(!0);
+    error.set(null);
+    const timeoutId = setTimeout(() => abortController?.abort(), timeout);
+    try {
+      let requestBody;
+      if (body)
+        if (typeof body === "object" && !(body instanceof FormData) && !(body instanceof URLSearchParams)) {
+          requestBody = JSON.stringify(body);
+          fetchOptions.headers = {
+            "Content-Type": "application/json",
+            ...fetchOptions.headers
+          };
+        } else
+          requestBody = body;
+      const response = await fetch(getURL(), {
+        ...fetchOptions,
+        body: requestBody,
+        signal: abortController.signal
+      });
+      clearTimeout(timeoutId);
+      status.set(response.status);
+      statusText.set(response.statusText);
+      if (!response.ok)
+        throw Error(`HTTP ${response.status}: ${response.statusText}`);
+      let payload = await parseResponse(response);
+      if (transform)
+        payload = transform(payload);
+      setCache(payload);
+      data.set(payload);
+      loading.set(!1);
+    } catch (err) {
+      clearTimeout(timeoutId);
+      if (err instanceof Error && err.name === "AbortError")
+        return;
+      if (attempt < retry) {
+        await new Promise((resolve) => setTimeout(resolve, retryDelay));
+        return doFetch(attempt + 1);
+      }
+      error.set(err instanceof Error ? err : Error(String(err)));
+      loading.set(!1);
+    }
+  }, setupRefetchOnFocus = () => {
+    if (!refetchOnFocus || typeof window > "u")
+      return;
+    focusHandler = () => {
+      if (document.visibilityState === "visible")
+        doFetch();
+    };
+    document.addEventListener("visibilitychange", focusHandler);
+  }, setupRefetchInterval = () => {
+    if (!refetchInterval || typeof window > "u")
+      return;
+    intervalId = setInterval(() => void doFetch(), refetchInterval);
+  };
+  if (immediate) {
+    doFetch();
+    setupRefetchOnFocus();
+    setupRefetchInterval();
+  }
+  return {
+    data,
+    loading,
+    error,
+    status,
+    statusText,
+    refetch: () => doFetch(),
+    execute: async () => {
+      await doFetch();
+      setupRefetchOnFocus();
+      setupRefetchInterval();
+    },
+    abort: () => {
+      if (abortController)
+        abortController.abort();
+      if (focusHandler) {
+        document.removeEventListener("visibilitychange", focusHandler);
+        focusHandler = null;
+      }
+      if (intervalId) {
+        clearInterval(intervalId);
+        intervalId = null;
+      }
+    }
+  };
+}
+export function useAsyncData(fetcher, options = {}) {
+  const {
+    immediate = !0,
+    transform,
+    initialData = null,
+    key,
+    cacheTime = 0
+  } = options, data = state(initialData), loading = state(!1), error = state(null), status = state(null), statusText = state(null), getCacheKey = () => key || fetcher.toString(), getFromCache = () => {
+    if (cacheTime <= 0)
+      return null;
+    const cached = fetchCache.get(getCacheKey());
+    if (cached && Date.now() - cached.timestamp < cacheTime)
+      return cached.data;
+    return null;
+  }, setCache = (value) => {
+    if (cacheTime > 0)
+      fetchCache.set(getCacheKey(), { data: value, timestamp: Date.now() });
+  }, doFetch = async () => {
+    const cached = getFromCache();
+    if (cached !== null) {
+      data.set(cached);
+      loading.set(!1);
+      error.set(null);
+      return;
+    }
+    loading.set(!0);
+    error.set(null);
+    try {
+      let payload = await fetcher();
+      if (transform)
+        payload = transform(payload);
+      setCache(payload);
+      data.set(payload);
+      loading.set(!1);
+    } catch (err) {
+      error.set(err instanceof Error ? err : Error(String(err)));
+      loading.set(!1);
+    }
+  };
+  if (immediate)
+    doFetch();
+  return {
+    data,
+    loading,
+    error,
+    status,
+    statusText,
+    refetch: doFetch,
+    execute: doFetch,
+    abort: () => {}
+  };
+}
+export function usePost(url, options = {}) {
+  let requestBody;
+  const fetchState = useFetch(url, {
+    ...options,
+    method: "POST",
+    immediate: !1,
+    get body() {
+      return requestBody;
+    }
+  });
+  return {
+    execute: async (body) => {
+      requestBody = body;
+      await fetchState.execute();
+      return fetchState.data();
+    },
+    state: fetchState
+  };
+}
+export function clearFetchCache(key) {
+  if (key)
+    fetchCache.delete(key);
+  else
+    fetchCache.clear();
+}
+export async function prefetch(url, options) {
+  await useFetch(url, { ...options, immediate: !1 }).execute();
+}

package/dist/composables/use-fullscreen.js

@@ -1,2 +1,110 @@
-// @bun
-import"../chunk-xv34zbp4.js";function I(){return document.fullscreenElement||document.webkitFullscreenElement||document.mozFullScreenElement||document.msFullscreenElement||null}function P(){return!!(document.fullscreenEnabled||document.webkitFullscreenEnabled||document.mozFullScreenEnabled||document.msFullscreenEnabled)}async function Q(b,D){let A=D?.navigationUI?{navigationUI:D.navigationUI}:void 0;if(b.requestFullscreen)await b.requestFullscreen(A);else if(b.webkitRequestFullscreen)await b.webkitRequestFullscreen();else if(b.mozRequestFullScreen)await b.mozRequestFullScreen();else if(b.msRequestFullscreen)await b.msRequestFullscreen()}async function R(){if(document.exitFullscreen)await document.exitFullscreen();else if(document.webkitExitFullscreen)await document.webkitExitFullscreen();else if(document.mozCancelFullScreen)await document.mozCancelFullScreen();else if(document.msExitFullscreen)await document.msExitFullscreen()}function T(b,D={}){let A=typeof document<"u"&&P(),w={isFullscreen:!1,isSupported:A,element:null},z=[],G=null,M=()=>{if(!b)return document.documentElement;if(typeof b==="function")return b()||document.documentElement;return b},N=()=>{z.forEach((j)=>j(w))},H=()=>{let j=I();w={...w,isFullscreen:!!j,element:j},N()},O=()=>{if(typeof document>"u")return;let j=["fullscreenchange","webkitfullscreenchange","mozfullscreenchange","MSFullscreenChange"];for(let B of j)document.addEventListener(B,H);G=()=>{for(let B of j)document.removeEventListener(B,H)},H()},J=async()=>{if(!A)return;let j=M();await Q(j,D)},K=async()=>{if(!A)return;if(I())await R()};return{get:()=>w,subscribe:(j)=>{if(z.length===0)O();return z.push(j),j(w),()=>{if(z=z.filter((B)=>B!==j),z.length===0&&G)G(),G=null}},isFullscreen:()=>w.isFullscreen,isSupported:()=>w.isSupported,enter:J,exit:K,toggle:async()=>{if(w.isFullscreen)await K();else await J()}}}function V(){return T().toggle()}function W(){return!!I()}export{T as useFullscreen,V as toggleFullscreen,W as isInFullscreen};
+function getFullscreenElement() {
+  return document.fullscreenElement || document.webkitFullscreenElement || document.mozFullScreenElement || document.msFullscreenElement || null;
+}
+function isFullscreenSupported() {
+  return !!(document.fullscreenEnabled || document.webkitFullscreenEnabled || document.mozFullScreenEnabled || document.msFullscreenEnabled);
+}
+async function requestFullscreen(element, options) {
+  const opts = options?.navigationUI ? { navigationUI: options.navigationUI } : void 0;
+  if (element.requestFullscreen)
+    await element.requestFullscreen(opts);
+  else if (element.webkitRequestFullscreen)
+    await element.webkitRequestFullscreen();
+  else if (element.mozRequestFullScreen)
+    await element.mozRequestFullScreen();
+  else if (element.msRequestFullscreen)
+    await element.msRequestFullscreen();
+}
+async function exitFullscreen() {
+  if (document.exitFullscreen)
+    await document.exitFullscreen();
+  else if (document.webkitExitFullscreen)
+    await document.webkitExitFullscreen();
+  else if (document.mozCancelFullScreen)
+    await document.mozCancelFullScreen();
+  else if (document.msExitFullscreen)
+    await document.msExitFullscreen();
+}
+export function useFullscreen(target, options = {}) {
+  const supported = typeof document < "u" && isFullscreenSupported();
+  let state = {
+    isFullscreen: !1,
+    isSupported: supported,
+    element: null
+  }, listeners = [], cleanup = null;
+  const getElement = () => {
+    if (!target)
+      return document.documentElement;
+    if (typeof target === "function")
+      return target() || document.documentElement;
+    return target;
+  }, notify = () => {
+    listeners.forEach((fn) => fn(state));
+  }, updateState = () => {
+    const fullscreenElement = getFullscreenElement();
+    state = {
+      ...state,
+      isFullscreen: !!fullscreenElement,
+      element: fullscreenElement
+    };
+    notify();
+  }, setupListeners = () => {
+    if (typeof document > "u")
+      return;
+    const events = [
+      "fullscreenchange",
+      "webkitfullscreenchange",
+      "mozfullscreenchange",
+      "MSFullscreenChange"
+    ];
+    for (const event of events)
+      document.addEventListener(event, updateState);
+    cleanup = () => {
+      for (const event of events)
+        document.removeEventListener(event, updateState);
+    };
+    updateState();
+  }, enter = async () => {
+    if (!supported)
+      return;
+    const element = getElement();
+    await requestFullscreen(element, options);
+  }, exit = async () => {
+    if (!supported)
+      return;
+    if (getFullscreenElement())
+      await exitFullscreen();
+  };
+  return {
+    get: () => state,
+    subscribe: (fn) => {
+      if (listeners.length === 0)
+        setupListeners();
+      listeners.push(fn);
+      fn(state);
+      return () => {
+        listeners = listeners.filter((l) => l !== fn);
+        if (listeners.length === 0 && cleanup) {
+          cleanup();
+          cleanup = null;
+        }
+      };
+    },
+    isFullscreen: () => state.isFullscreen,
+    isSupported: () => state.isSupported,
+    enter,
+    exit,
+    toggle: async () => {
+      if (state.isFullscreen)
+        await exit();
+      else
+        await enter();
+    }
+  };
+}
+export function toggleFullscreen() {
+  return useFullscreen().toggle();
+}
+export function isInFullscreen() {
+  return !!getFullscreenElement();
+}