@stacksjs/stx 0.2.95 → 0.2.96

package/dist/composables/use-notification.js

@@ -1,2 +1,94 @@
-// @bun
-import"../chunk-xv34zbp4.js";var A=new Map;function K(){let j=typeof window<"u"&&"Notification"in window,b={permission:j?Notification.permission:"denied",isSupported:j},z=[],G=()=>{z.forEach((k)=>k(b))},L=()=>{if(!j)return;b={...b,permission:Notification.permission},G()};return{get:()=>b,subscribe:(k)=>{return z.push(k),k(b),()=>{z=z.filter((q)=>q!==k)}},isSupported:()=>b.isSupported,permission:()=>b.permission,requestPermission:async()=>{if(!j)return"denied";try{let k=await Notification.requestPermission();return b={...b,permission:k},G(),k}catch{return b.permission}},show:(k,q={})=>{if(!j||b.permission!=="granted")return null;let{autoClose:F,...J}=q;try{let B=new Notification(k,J);if(q.tag){let H=A.get(q.tag);if(H)H.close();A.set(q.tag,B),B.addEventListener("close",()=>{A.delete(q.tag)})}if(F&&F>0)setTimeout(()=>{B.close()},F);return B}catch{return null}},close:(k)=>{let q=A.get(k);if(q)q.close(),A.delete(k)}}}async function D(j,b){let z=K();if(z.permission()==="default")await z.requestPermission();return z.show(j,b)}function R(){return typeof window<"u"&&"Notification"in window&&Notification.permission==="granted"}async function T(){if(typeof window>"u"||!("Notification"in window))return"denied";return Notification.requestPermission()}var U={success:(j,b)=>D("Success",{body:j,icon:"\u2705",...b}),error:(j,b)=>D("Error",{body:j,icon:"\u274C",...b}),warning:(j,b)=>D("Warning",{body:j,icon:"\u26A0\uFE0F",...b}),info:(j,b)=>D("Info",{body:j,icon:"\u2139\uFE0F",...b})};export{K as useNotification,T as requestNotificationPermission,D as notify,U as notifications,R as canNotify};
+const activeNotifications = new Map;
+export function useNotification() {
+  const isSupported = typeof window < "u" && "Notification" in window;
+  let state = {
+    permission: isSupported ? Notification.permission : "denied",
+    isSupported
+  }, listeners = [];
+  const notify = () => {
+    listeners.forEach((fn) => fn(state));
+  }, updatePermission = () => {
+    if (!isSupported)
+      return;
+    state = {
+      ...state,
+      permission: Notification.permission
+    };
+    notify();
+  };
+  return {
+    get: () => state,
+    subscribe: (fn) => {
+      listeners.push(fn);
+      fn(state);
+      return () => {
+        listeners = listeners.filter((l) => l !== fn);
+      };
+    },
+    isSupported: () => state.isSupported,
+    permission: () => state.permission,
+    requestPermission: async () => {
+      if (!isSupported)
+        return "denied";
+      try {
+        const result = await Notification.requestPermission();
+        state = { ...state, permission: result };
+        notify();
+        return result;
+      } catch {
+        return state.permission;
+      }
+    },
+    show: (title, options = {}) => {
+      if (!isSupported || state.permission !== "granted")
+        return null;
+      const { autoClose, ...notificationOptions } = options;
+      try {
+        const notification = new Notification(title, notificationOptions);
+        if (options.tag) {
+          const existing = activeNotifications.get(options.tag);
+          if (existing)
+            existing.close();
+          activeNotifications.set(options.tag, notification);
+          notification.addEventListener("close", () => {
+            activeNotifications.delete(options.tag);
+          });
+        }
+        if (autoClose && autoClose > 0)
+          setTimeout(() => {
+            notification.close();
+          }, autoClose);
+        return notification;
+      } catch {
+        return null;
+      }
+    },
+    close: (tag) => {
+      const notification = activeNotifications.get(tag);
+      if (notification) {
+        notification.close();
+        activeNotifications.delete(tag);
+      }
+    }
+  };
+}
+export async function notify(title, options) {
+  const notifier = useNotification();
+  if (notifier.permission() === "default")
+    await notifier.requestPermission();
+  return notifier.show(title, options);
+}
+export function canNotify() {
+  return typeof window < "u" && "Notification" in window && Notification.permission === "granted";
+}
+export async function requestNotificationPermission() {
+  if (typeof window > "u" || !("Notification" in window))
+    return "denied";
+  return Notification.requestPermission();
+}
+export const notifications = {
+  success: (message, options) => notify("Success", { body: message, icon: "\u2705", ...options }),
+  error: (message, options) => notify("Error", { body: message, icon: "\u274C", ...options }),
+  warning: (message, options) => notify("Warning", { body: message, icon: "\u26A0\uFE0F", ...options }),
+  info: (message, options) => notify("Info", { body: message, icon: "\u2139\uFE0F", ...options })
+};

package/dist/composables/use-permissions.js

@@ -1,2 +1,132 @@
-// @bun
-import"../chunk-xv34zbp4.js";function B(k){return{state:k,isGranted:k==="granted",isDenied:k==="denied",isPrompt:k==="prompt"}}function I(){return typeof navigator<"u"&&"permissions"in navigator}function J(k){let x=I(),h=B("prompt"),w=[],z=null,A=null,F=()=>{w.forEach((j)=>j(h))},H=()=>{if(z)h=B(z.state),F()},v=async()=>{if(!x)return B("prompt");try{return z=await navigator.permissions.query({name:k}),h=B(z.state),z.addEventListener("change",H),A=()=>{z?.removeEventListener("change",H)},h}catch{return B("prompt")}};return{get:()=>h,subscribe:(j)=>{if(w.length===0&&x)v();return w.push(j),j(h),()=>{if(w=w.filter((D)=>D!==j),w.length===0&&A)A(),A=null}},query:v,isSupported:()=>x}}function L(k){let x=I(),h={},w=[],z={},A=[];for(let v of k)h[v]=B("prompt"),z[v]=J(v);let F=()=>{w.forEach((v)=>v(h))};return{get:()=>h,subscribe:(v)=>{if(w.length===0)for(let j of k){let D=z[j].subscribe((K)=>{h[j]=K,F()});A.push(D)}return w.push(v),v(h),()=>{if(w=w.filter((j)=>j!==v),w.length===0)A.forEach((j)=>j()),A.length=0}},queryAll:async()=>{let v=await Promise.all(k.map(async(j)=>{let D=await z[j].query();return[j,D]}));return h=Object.fromEntries(v),h},isSupported:()=>x}}async function E(k){return(await J(k).query()).isGranted}async function M(){return E("camera")}async function N(){return E("microphone")}async function O(){return E("geolocation")}async function Q(){return E("notifications")}async function T(k={video:!0,audio:!0}){if(typeof navigator>"u"||!navigator.mediaDevices)return{granted:!1,error:Error("MediaDevices API not supported")};try{return{granted:!0,stream:await navigator.mediaDevices.getUserMedia(k)}}catch(x){return{granted:!1,error:x instanceof Error?x:Error(String(x))}}}var U={media:["camera","microphone"],location:["geolocation"],notifications:["notifications","push"],sensors:["accelerometer","gyroscope","magnetometer"],clipboard:["clipboard-read","clipboard-write"]};export{L as usePermissions,J as usePermission,T as requestMediaPermissions,U as permissionGroups,E as isPermissionGranted,Q as hasNotificationPermission,N as hasMicrophonePermission,O as hasGeolocationPermission,M as hasCameraPermission};
+function createStatus(state) {
+  return {
+    state,
+    isGranted: state === "granted",
+    isDenied: state === "denied",
+    isPrompt: state === "prompt"
+  };
+}
+function isPermissionsSupported() {
+  return typeof navigator < "u" && "permissions" in navigator;
+}
+export function usePermission(name) {
+  const supported = isPermissionsSupported();
+  let status = createStatus("prompt"), listeners = [], permissionStatus = null, cleanup = null;
+  const notify = () => {
+    listeners.forEach((fn) => fn(status));
+  }, updateStatus = () => {
+    if (permissionStatus) {
+      status = createStatus(permissionStatus.state);
+      notify();
+    }
+  }, query = async () => {
+    if (!supported)
+      return createStatus("prompt");
+    try {
+      permissionStatus = await navigator.permissions.query({ name });
+      status = createStatus(permissionStatus.state);
+      permissionStatus.addEventListener("change", updateStatus);
+      cleanup = () => {
+        permissionStatus?.removeEventListener("change", updateStatus);
+      };
+      return status;
+    } catch {
+      return createStatus("prompt");
+    }
+  };
+  return {
+    get: () => status,
+    subscribe: (fn) => {
+      if (listeners.length === 0 && supported)
+        query();
+      listeners.push(fn);
+      fn(status);
+      return () => {
+        listeners = listeners.filter((l) => l !== fn);
+        if (listeners.length === 0 && cleanup) {
+          cleanup();
+          cleanup = null;
+        }
+      };
+    },
+    query,
+    isSupported: () => supported
+  };
+}
+export function usePermissions(names) {
+  const supported = isPermissionsSupported();
+  let states = {}, listeners = [];
+  const permissionRefs = {}, unsubscribers = [];
+  for (const name of names) {
+    states[name] = createStatus("prompt");
+    permissionRefs[name] = usePermission(name);
+  }
+  const notify = () => {
+    listeners.forEach((fn) => fn(states));
+  };
+  return {
+    get: () => states,
+    subscribe: (fn) => {
+      if (listeners.length === 0)
+        for (const name of names) {
+          const unsub = permissionRefs[name].subscribe((status) => {
+            states[name] = status;
+            notify();
+          });
+          unsubscribers.push(unsub);
+        }
+      listeners.push(fn);
+      fn(states);
+      return () => {
+        listeners = listeners.filter((l) => l !== fn);
+        if (listeners.length === 0) {
+          unsubscribers.forEach((unsub) => unsub());
+          unsubscribers.length = 0;
+        }
+      };
+    },
+    queryAll: async () => {
+      const results = await Promise.all(names.map(async (name) => {
+        const result = await permissionRefs[name].query();
+        return [name, result];
+      }));
+      states = Object.fromEntries(results);
+      return states;
+    },
+    isSupported: () => supported
+  };
+}
+export async function isPermissionGranted(name) {
+  return (await usePermission(name).query()).isGranted;
+}
+export async function hasCameraPermission() {
+  return isPermissionGranted("camera");
+}
+export async function hasMicrophonePermission() {
+  return isPermissionGranted("microphone");
+}
+export async function hasGeolocationPermission() {
+  return isPermissionGranted("geolocation");
+}
+export async function hasNotificationPermission() {
+  return isPermissionGranted("notifications");
+}
+export async function requestMediaPermissions(options = { video: !0, audio: !0 }) {
+  if (typeof navigator > "u" || !navigator.mediaDevices)
+    return { granted: !1, error: Error("MediaDevices API not supported") };
+  try {
+    return { granted: !0, stream: await navigator.mediaDevices.getUserMedia(options) };
+  } catch (err) {
+    return {
+      granted: !1,
+      error: err instanceof Error ? err : Error(String(err))
+    };
+  }
+}
+export const permissionGroups = {
+  media: ["camera", "microphone"],
+  location: ["geolocation"],
+  notifications: ["notifications", "push"],
+  sensors: ["accelerometer", "gyroscope", "magnetometer"],
+  clipboard: ["clipboard-read", "clipboard-write"]
+};

package/dist/composables/use-query.js

@@ -1 +0,0 @@
-// @bun

package/dist/composables/use-resize-observer.js

@@ -1,2 +1,157 @@
-// @bun
-import"../chunk-xv34zbp4.js";function P(){return typeof window<"u"&&"ResizeObserver"in window}function I(F){if(!F||F.length===0)return null;let A=F[0];return{width:A.inlineSize,height:A.blockSize,inlineSize:A.inlineSize,blockSize:A.blockSize}}function Q(F,A,G={}){let H=P(),D={contentRect:null,contentBoxSize:null,borderBoxSize:null,devicePixelContentBoxSize:null},w=[],B=null,L=()=>{if(typeof F==="function")return F();return F},N=(j)=>{if(j.length>0){let q=j[0];D={contentRect:q.contentRect,contentBoxSize:I(q.contentBoxSize),borderBoxSize:I(q.borderBoxSize),devicePixelContentBoxSize:I(q.devicePixelContentBoxSize)}}if(A)A(j);w.forEach((q)=>q(j))},J=()=>{if(!H)return;let j=L();if(!j)return;if(!B)B=new ResizeObserver(N);B.observe(j,{box:G.box})},K=()=>{if(B)B.disconnect(),B=null};return{get:()=>D,subscribe:(j)=>{if(w.length===0)J();return w.push(j),()=>{if(w=w.filter((q)=>q!==j),w.length===0&&!A)K()}},observe:J,disconnect:K,isSupported:()=>H}}function T(F,A,G={}){let H=P(),D=new Map,w=[],B=null,L=()=>{if(typeof F==="function")return F();return F},N=(j)=>{for(let q of j)D.set(q.target,{contentRect:q.contentRect,contentBoxSize:I(q.contentBoxSize),borderBoxSize:I(q.borderBoxSize),devicePixelContentBoxSize:I(q.devicePixelContentBoxSize)});if(A)A(j);w.forEach((q)=>q(j))},J=()=>{if(!H)return;let j=L();if(j.length===0)return;if(!B)B=new ResizeObserver(N);for(let q of j)B.observe(q,{box:G.box})},K=()=>{if(B)B.disconnect(),B=null;D.clear()};return{get:()=>D.values().next().value||{contentRect:null,contentBoxSize:null,borderBoxSize:null,devicePixelContentBoxSize:null},states:()=>D,subscribe:(j)=>{if(w.length===0)J();return w.push(j),()=>{if(w=w.filter((q)=>q!==j),w.length===0&&!A)K()}},observe:J,disconnect:K,isSupported:()=>H}}function U(F){let A={width:0,height:0},G=[],H=Q(F,(D)=>{if(D.length>0){let w=D[0].contentRect;A={width:w.width,height:w.height},G.forEach((B)=>B(A))}});return{get:()=>A,subscribe:(D)=>{if(G.push(D),D(A),G.length===1)H.observe();return()=>{if(G=G.filter((w)=>w!==D),G.length===0)H.disconnect()}},isSupported:H.isSupported}}function V(){return P()}export{T as useResizeObserverMultiple,Q as useResizeObserver,U as useElementSize,V as hasResizeObserver};
+function isResizeObserverSupported() {
+  return typeof window < "u" && "ResizeObserver" in window;
+}
+function extractSize(sizes) {
+  if (!sizes || sizes.length === 0)
+    return null;
+  const size = sizes[0];
+  return {
+    width: size.inlineSize,
+    height: size.blockSize,
+    inlineSize: size.inlineSize,
+    blockSize: size.blockSize
+  };
+}
+export function useResizeObserver(target, callback, options = {}) {
+  const supported = isResizeObserverSupported();
+  let state = {
+    contentRect: null,
+    contentBoxSize: null,
+    borderBoxSize: null,
+    devicePixelContentBoxSize: null
+  }, listeners = [], observer = null;
+  const getElement = () => {
+    if (typeof target === "function")
+      return target();
+    return target;
+  }, notify = (entries) => {
+    if (entries.length > 0) {
+      const entry = entries[0];
+      state = {
+        contentRect: entry.contentRect,
+        contentBoxSize: extractSize(entry.contentBoxSize),
+        borderBoxSize: extractSize(entry.borderBoxSize),
+        devicePixelContentBoxSize: extractSize(entry.devicePixelContentBoxSize)
+      };
+    }
+    if (callback)
+      callback(entries);
+    listeners.forEach((fn) => fn(entries));
+  }, observe = () => {
+    if (!supported)
+      return;
+    const element = getElement();
+    if (!element)
+      return;
+    if (!observer)
+      observer = new ResizeObserver(notify);
+    observer.observe(element, { box: options.box });
+  }, disconnect = () => {
+    if (observer) {
+      observer.disconnect();
+      observer = null;
+    }
+  };
+  return {
+    get: () => state,
+    subscribe: (fn) => {
+      if (listeners.length === 0)
+        observe();
+      listeners.push(fn);
+      return () => {
+        listeners = listeners.filter((l) => l !== fn);
+        if (listeners.length === 0 && !callback)
+          disconnect();
+      };
+    },
+    observe,
+    disconnect,
+    isSupported: () => supported
+  };
+}
+export function useResizeObserverMultiple(targets, callback, options = {}) {
+  const supported = isResizeObserverSupported(), statesMap = new Map;
+  let listeners = [], observer = null;
+  const getElements = () => {
+    if (typeof targets === "function")
+      return targets();
+    return targets;
+  }, notify = (entries) => {
+    for (const entry of entries)
+      statesMap.set(entry.target, {
+        contentRect: entry.contentRect,
+        contentBoxSize: extractSize(entry.contentBoxSize),
+        borderBoxSize: extractSize(entry.borderBoxSize),
+        devicePixelContentBoxSize: extractSize(entry.devicePixelContentBoxSize)
+      });
+    if (callback)
+      callback(entries);
+    listeners.forEach((fn) => fn(entries));
+  }, observe = () => {
+    if (!supported)
+      return;
+    const elements = getElements();
+    if (elements.length === 0)
+      return;
+    if (!observer)
+      observer = new ResizeObserver(notify);
+    for (const element of elements)
+      observer.observe(element, { box: options.box });
+  }, disconnect = () => {
+    if (observer) {
+      observer.disconnect();
+      observer = null;
+    }
+    statesMap.clear();
+  };
+  return {
+    get: () => statesMap.values().next().value || {
+      contentRect: null,
+      contentBoxSize: null,
+      borderBoxSize: null,
+      devicePixelContentBoxSize: null
+    },
+    states: () => statesMap,
+    subscribe: (fn) => {
+      if (listeners.length === 0)
+        observe();
+      listeners.push(fn);
+      return () => {
+        listeners = listeners.filter((l) => l !== fn);
+        if (listeners.length === 0 && !callback)
+          disconnect();
+      };
+    },
+    observe,
+    disconnect,
+    isSupported: () => supported
+  };
+}
+export function useElementSize(target) {
+  let size = { width: 0, height: 0 }, listeners = [];
+  const observer = useResizeObserver(target, (entries) => {
+    if (entries.length > 0) {
+      const rect = entries[0].contentRect;
+      size = { width: rect.width, height: rect.height };
+      listeners.forEach((fn) => fn(size));
+    }
+  });
+  return {
+    get: () => size,
+    subscribe: (fn) => {
+      listeners.push(fn);
+      fn(size);
+      if (listeners.length === 1)
+        observer.observe();
+      return () => {
+        listeners = listeners.filter((l) => l !== fn);
+        if (listeners.length === 0)
+          observer.disconnect();
+      };
+    },
+    isSupported: observer.isSupported
+  };
+}
+export function hasResizeObserver() {
+  return isResizeObserverSupported();
+}

package/dist/composables/use-router.js

@@ -1,2 +1,51 @@
-// @bun
-import"../chunk-xv34zbp4.js";function y(f){if(typeof window<"u")if(window.stxRouter?.navigate)window.stxRouter.navigate(f);else window.location.href=f}function z(){if(typeof window<"u")window.history.back()}function B(){if(typeof window<"u")window.history.forward()}function C(){if(typeof window>"u")return{path:"/",fullPath:"/",hash:"",query:{},params:{}};if(window.stx?.useRoute)return window.stx.useRoute();return{get path(){return window.location.pathname},get fullPath(){return window.location.pathname+window.location.search+window.location.hash},get hash(){return window.location.hash},get query(){let f={};return new URLSearchParams(window.location.search).forEach((j,q)=>{f[q]=j}),f},get params(){return window.stx?._rp??{}}}}function D(f){if(typeof window<"u"&&window.stx?.setRouteParams)window.stx.setRouteParams(f)}function E(){return{data:Object.assign(()=>({}),{set:()=>{}}),get:()=>{return},set:()=>{},setAll:()=>{}}}export{E as useSearchParams,C as useRoute,D as setRouteParams,y as navigate,B as goForward,z as goBack};
+export function navigate(url) {
+  if (typeof window < "u")
+    if (window.stxRouter?.navigate)
+      window.stxRouter.navigate(url);
+    else
+      window.location.href = url;
+}
+export function goBack() {
+  if (typeof window < "u")
+    window.history.back();
+}
+export function goForward() {
+  if (typeof window < "u")
+    window.history.forward();
+}
+export function useRoute() {
+  if (typeof window > "u")
+    return { path: "/", fullPath: "/", hash: "", query: {}, params: {} };
+  if (window.stx?.useRoute)
+    return window.stx.useRoute();
+  return {
+    get path() {
+      return window.location.pathname;
+    },
+    get fullPath() {
+      return window.location.pathname + window.location.search + window.location.hash;
+    },
+    get hash() {
+      return window.location.hash;
+    },
+    get query() {
+      const params = {};
+      new URLSearchParams(window.location.search).forEach((v, k) => {
+        params[k] = v;
+      });
+      return params;
+    },
+    get params() {
+      return window.stx?._rp ?? {};
+    }
+  };
+}
+export function setRouteParams(params) {
+  if (typeof window < "u" && window.stx?.setRouteParams)
+    window.stx.setRouteParams(params);
+}
+export function useSearchParams() {
+  return { data: Object.assign(() => ({}), { set: () => {} }), get: () => {
+    return;
+  }, set: () => {}, setAll: () => {} };
+}

package/dist/composables/use-share.js

@@ -1,2 +1,104 @@
-// @bun
-import"../chunk-xv34zbp4.js";function H(){return typeof navigator<"u"&&"share"in navigator}function I(){return typeof navigator<"u"&&"canShare"in navigator}function G(){let q=H(),z=I(),A=(j)=>{if(!q)return!1;if(!j)return!0;if(j.files&&j.files.length>0){if(!z)return!1;try{return navigator.canShare(j)}catch{return!1}}return!!(j.title||j.text||j.url)};return{isSupported:()=>q,isFileShareSupported:()=>z,canShare:A,share:async(j)=>{if(!q)return{success:!1,error:Error("Web Share API is not supported")};if(!j.title&&!j.text&&!j.url&&(!j.files||j.files.length===0))return{success:!1,error:Error("Share data must include at least one of: title, text, url, or files")};if(!A(j))return{success:!1,error:Error("This content cannot be shared on this device")};try{return await navigator.share(j),{success:!0}}catch(B){if(B instanceof Error&&B.name==="AbortError")return{success:!1,cancelled:!0};return{success:!1,error:B instanceof Error?B:Error(String(B))}}}}}async function D(q){return G().share(q)}async function J(q,z,A){return D({url:q,title:z,text:A})}async function K(q,z){return D({text:q,title:z})}async function L(q,z,A){return D({files:q,title:z,text:A})}function N(q,z,A){return new File([q],z,{type:A||q.type})}async function O(q){if(typeof document>"u"||typeof location>"u")return{success:!1,error:Error("Not in browser environment")};return D({title:document.title,url:location.href,text:q})}async function P(q,z){let A=G();if(A.isSupported()&&A.canShare(q)){let j=await A.share(q);if(j.success||j.cancelled)return j}let E=q.url||q.text||q.title||"";if(!E)return{success:!1,error:Error("Nothing to copy")};try{if(await navigator.clipboard.writeText(E),z)alert(z);return{success:!0,usedFallback:!0}}catch(j){return{success:!1,error:j instanceof Error?j:Error(String(j)),usedFallback:!0}}}export{G as useShare,P as shareWithFallback,J as shareURL,K as shareText,L as shareFiles,O as shareCurrentPage,D as share,N as createShareableFile};
+function isShareSupported() {
+  return typeof navigator < "u" && "share" in navigator;
+}
+function isFileShareSupported() {
+  return typeof navigator < "u" && "canShare" in navigator;
+}
+export function useShare() {
+  const supported = isShareSupported(), fileSupported = isFileShareSupported(), canShare = (data) => {
+    if (!supported)
+      return !1;
+    if (!data)
+      return !0;
+    if (data.files && data.files.length > 0) {
+      if (!fileSupported)
+        return !1;
+      try {
+        return navigator.canShare(data);
+      } catch {
+        return !1;
+      }
+    }
+    return !!(data.title || data.text || data.url);
+  };
+  return {
+    isSupported: () => supported,
+    isFileShareSupported: () => fileSupported,
+    canShare,
+    share: async (data) => {
+      if (!supported)
+        return {
+          success: !1,
+          error: Error("Web Share API is not supported")
+        };
+      if (!data.title && !data.text && !data.url && (!data.files || data.files.length === 0))
+        return {
+          success: !1,
+          error: Error("Share data must include at least one of: title, text, url, or files")
+        };
+      if (!canShare(data))
+        return {
+          success: !1,
+          error: Error("This content cannot be shared on this device")
+        };
+      try {
+        await navigator.share(data);
+        return { success: !0 };
+      } catch (err) {
+        if (err instanceof Error && err.name === "AbortError")
+          return { success: !1, cancelled: !0 };
+        return {
+          success: !1,
+          error: err instanceof Error ? err : Error(String(err))
+        };
+      }
+    }
+  };
+}
+export async function share(data) {
+  return useShare().share(data);
+}
+export async function shareURL(url, title, text) {
+  return share({ url, title, text });
+}
+export async function shareText(text, title) {
+  return share({ text, title });
+}
+export async function shareFiles(files, title, text) {
+  return share({ files, title, text });
+}
+export function createShareableFile(blob, filename, mimeType) {
+  return new File([blob], filename, { type: mimeType || blob.type });
+}
+export async function shareCurrentPage(text) {
+  if (typeof document > "u" || typeof location > "u")
+    return { success: !1, error: Error("Not in browser environment") };
+  return share({
+    title: document.title,
+    url: location.href,
+    text
+  });
+}
+export async function shareWithFallback(data, fallbackMessage) {
+  const sharer = useShare();
+  if (sharer.isSupported() && sharer.canShare(data)) {
+    const result = await sharer.share(data);
+    if (result.success || result.cancelled)
+      return result;
+  }
+  const textToCopy = data.url || data.text || data.title || "";
+  if (!textToCopy)
+    return { success: !1, error: Error("Nothing to copy") };
+  try {
+    await navigator.clipboard.writeText(textToCopy);
+    if (fallbackMessage)
+      alert(fallbackMessage);
+    return { success: !0, usedFallback: !0 };
+  } catch (err) {
+    return {
+      success: !1,
+      error: err instanceof Error ? err : Error(String(err)),
+      usedFallback: !0
+    };
+  }
+}