@akanjs/next 0.0.53 → 0.0.55

package/useContact.mjs

@@ -0,0 +1,36 @@
+"use client";
+import { device } from "@akanjs/client";
+import { Contacts } from "@capacitor-community/contacts";
+import { useEffect, useState } from "react";
+const useContact = () => {
+  const [permissions, setPermissions] = useState({ contacts: "prompt" });
+  const checkPermission = async () => {
+    try {
+      if (permissions.contacts === "prompt") {
+        const { contacts } = await Contacts.requestPermissions();
+        setPermissions((prev) => ({ ...prev, contacts }));
+      } else if (permissions.contacts === "denied") {
+        location.assign("app-settings:");
+        return;
+      }
+    } catch (e) {
+    }
+  };
+  const getContacts = async () => {
+    await checkPermission();
+    const { contacts } = await Contacts.getContacts({ projection: { name: true, phones: true } });
+    return contacts;
+  };
+  useEffect(() => {
+    void (async () => {
+      if (device.info.platform === "web")
+        return;
+      const permissions2 = await Contacts.checkPermissions();
+      setPermissions(permissions2);
+    })();
+  }, []);
+  return { permissions, getContacts, checkPermission };
+};
+export {
+  useContact
+};

package/useCsrValues.mjs

@@ -0,0 +1,596 @@
+"use client";
+import {
+  defaultPageState,
+  device,
+  router
+} from "@akanjs/client";
+import { App } from "@capacitor/app";
+import { useSpringValue } from "@react-spring/web";
+import { useDrag } from "@use-gesture/react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useHistory } from "./useHistory";
+import { useLocation } from "./useLocation";
+const useNoneTrans = ({ clientHeight, location, prevLocation }) => {
+  const transDirection = "none";
+  const transUnit = useSpringValue(0, { config: { clamp: true } });
+  const transUnitRange = useMemo(() => [0, 0], []);
+  const transProgress = transUnit.to((unit) => 1);
+  const transPercent = transUnit.to((unit) => 100);
+  const pageState = location.pathRoute.pageState;
+  const prevPageState = prevLocation?.pathRoute.pageState ?? defaultPageState;
+  const csrTranstionStyles = {
+    topSafeArea: {
+      containerStyle: {
+        height: pageState.topSafeArea
+      }
+    },
+    bottomSafeArea: {
+      containerStyle: {
+        top: clientHeight - pageState.bottomSafeArea,
+        height: pageState.bottomSafeArea
+      }
+    },
+    page: {
+      containerStyle: {},
+      contentStyle: {
+        paddingTop: pageState.topSafeArea + pageState.topInset,
+        paddingBottom: pageState.bottomInset + pageState.bottomSafeArea,
+        height: clientHeight
+      }
+    },
+    prevPage: {
+      containerStyle: {
+        paddingTop: prevPageState.topSafeArea + prevPageState.topInset
+      },
+      contentStyle: { opacity: 0 }
+    },
+    topInset: {
+      containerStyle: {
+        top: pageState.topSafeArea,
+        height: pageState.topInset
+      },
+      contentStyle: { opacity: 1 },
+      prevContentStyle: { opacity: 0 }
+    },
+    topLeftAction: {
+      containerStyle: {
+        top: pageState.topSafeArea,
+        height: pageState.topInset
+      },
+      contentStyle: { opacity: 1 },
+      prevContentStyle: { opacity: 0 }
+    },
+    bottomInset: {
+      containerStyle: {
+        height: pageState.bottomInset,
+        top: clientHeight - pageState.bottomInset - pageState.bottomSafeArea
+      },
+      contentStyle: { opacity: 1 },
+      prevContentStyle: { opacity: 0 }
+    }
+  };
+  const useCsrTransition = {
+    ...csrTranstionStyles,
+    pageBind: () => ({}),
+    pageClassName: "touch-pan-y",
+    transDirection,
+    transUnitRange,
+    transUnit,
+    transPercent,
+    transProgress
+  };
+  return useCsrTransition;
+};
+const useFadeTrans = ({ clientHeight, location, prevLocation, onBack, history }) => {
+  const transDirection = "none";
+  const transUnit = useSpringValue(1, { config: { clamp: true } });
+  const transUnitRange = useMemo(() => [0, 1], []);
+  const transProgress = transUnit.to((unit) => unit);
+  const transPercent = transUnit.to([0, 1], [0, 100], "clamp");
+  const pageState = location.pathRoute.pageState;
+  const prevPageState = prevLocation?.pathRoute.pageState ?? defaultPageState;
+  useEffect(() => {
+    onBack.current.fade = async () => {
+      await transUnit.start(transUnitRange[0]);
+    };
+  }, []);
+  useEffect(() => {
+    if (history.current.type === "forward") {
+      void transUnit.start(transUnitRange[0], { immediate: true });
+      void transUnit.start(transUnitRange[1], { config: { duration: 150 } });
+    } else {
+      void transUnit.start(transUnitRange[1], { immediate: true });
+      return;
+    }
+  }, [location.pathname]);
+  const csrTranstionStyles = {
+    topSafeArea: {
+      containerStyle: {
+        height: transProgress.to([0, 1], [prevPageState.topSafeArea, pageState.topSafeArea])
+      }
+    },
+    bottomSafeArea: {
+      containerStyle: {
+        top: transProgress.to(
+          [0, 1],
+          [clientHeight - prevPageState.bottomSafeArea, clientHeight - pageState.bottomSafeArea]
+        ),
+        height: transProgress.to([0, 1], [prevPageState.bottomSafeArea, pageState.bottomSafeArea])
+      }
+    },
+    page: {
+      containerStyle: {},
+      contentStyle: {
+        paddingTop: pageState.topSafeArea + pageState.topInset,
+        paddingBottom: pageState.bottomInset + pageState.bottomSafeArea,
+        opacity: transUnit,
+        height: clientHeight
+      }
+    },
+    prevPage: {
+      containerStyle: {
+        paddingTop: prevPageState.topSafeArea + prevPageState.topInset,
+        opacity: transProgress.to((progress) => 1 - progress)
+      },
+      contentStyle: {}
+    },
+    topInset: {
+      containerStyle: {
+        top: transProgress.to([0, 1], [prevPageState.topSafeArea, pageState.topSafeArea]),
+        height: transProgress.to([0, 1], [prevPageState.topInset, pageState.topInset])
+      },
+      contentStyle: {
+        opacity: transProgress
+      },
+      prevContentStyle: {
+        opacity: transProgress.to((progress) => 1 - progress)
+      }
+    },
+    topLeftAction: {
+      containerStyle: {
+        top: transProgress.to([0, 1], [prevPageState.topSafeArea, pageState.topSafeArea]),
+        height: transProgress.to([0, 1], [prevPageState.topInset, pageState.topInset])
+      },
+      contentStyle: {
+        opacity: transProgress.to((progress) => progress)
+      },
+      prevContentStyle: {
+        opacity: transProgress.to((progress) => 1 - progress)
+      }
+    },
+    bottomInset: {
+      containerStyle: {
+        height: transProgress.to([0, 1], [prevPageState.bottomInset, pageState.bottomInset]),
+        top: transProgress.to(
+          [0, 1],
+          [
+            clientHeight - prevPageState.bottomInset - prevPageState.bottomSafeArea,
+            clientHeight - pageState.bottomInset - pageState.bottomSafeArea
+          ]
+        )
+      },
+      contentStyle: {
+        top: transProgress.to([0, 1], [0, -(pageState.bottomInset - prevPageState.bottomInset) * 2]),
+        opacity: transProgress.to((progress) => progress)
+      },
+      prevContentStyle: {
+        top: transProgress.to([0, 1], [0, -(pageState.bottomInset - prevPageState.bottomInset) * 2]),
+        opacity: transProgress.to((progress) => 1 - progress)
+      }
+    }
+  };
+  const useCsrTransition = {
+    ...csrTranstionStyles,
+    pageBind: () => ({}),
+    pageClassName: "",
+    transDirection,
+    transUnitRange,
+    transUnit,
+    transPercent,
+    transProgress
+  };
+  return useCsrTransition;
+};
+const useStackTrans = ({
+  clientWidth,
+  clientHeight,
+  location,
+  prevLocation,
+  history,
+  onBack
+}) => {
+  const transDirection = "horizontal";
+  const transUnit = useSpringValue(0, { config: { clamp: true } });
+  const transUnitRange = useMemo(() => [clientWidth, 0], []);
+  const transUnitReversed = transUnit.to((unit) => transUnitRange[0] - unit);
+  const transUnitRangeReversed = useMemo(() => [0, clientWidth], []);
+  const transProgress = transUnitReversed.to(transUnitRangeReversed, [0, 1], "clamp");
+  const transPercent = transUnitReversed.to(transUnitRangeReversed, [0, 100], "clamp");
+  const initThreshold = useMemo(() => Math.floor(clientWidth), []);
+  const threshold = useMemo(() => Math.floor(clientWidth / 3), []);
+  const pageState = location.pathRoute.pageState;
+  const prevPageState = prevLocation?.pathRoute.pageState ?? defaultPageState;
+  const pageClassName = "touch-pan-y";
+  useEffect(() => {
+    onBack.current.stack = async () => {
+      await transUnit.start(transUnitRange[0]);
+    };
+  }, []);
+  useEffect(() => {
+    if (history.current.type === "forward") {
+      void transUnit.start(transUnitRange[0], { immediate: true });
+      void transUnit.start(transUnitRange[1], { config: { duration: 150 } });
+    } else {
+      void transUnit.start(transUnitRange[1], { immediate: true });
+      return;
+    }
+  }, [location.pathname]);
+  const pageBind = useDrag(
+    ({ first, down, last, movement: [mx], initial: [ix], cancel }) => {
+      if (first)
+        void device.hideKeyboard();
+      if (ix > initThreshold) {
+        cancel();
+        return;
+      }
+      if (mx < transUnitRange[1])
+        void transUnit.start(transUnitRange[1], { immediate: true });
+      else if (mx > transUnitRange[0])
+        void transUnit.start(transUnitRange[0], { immediate: true });
+      else if (!last)
+        void transUnit.start(mx, { immediate: true });
+      else if (mx < threshold)
+        void transUnit.start(transUnitRange[1]);
+      if (last && mx > threshold)
+        router.back();
+    },
+    { axis: "x", filterTaps: true }
+  );
+  const csrTranstionStyles = {
+    topSafeArea: {
+      containerStyle: {
+        height: transProgress.to([0, 1], [prevPageState.topSafeArea, pageState.topSafeArea])
+      }
+    },
+    bottomSafeArea: {
+      containerStyle: {
+        top: transProgress.to(
+          [0, 1],
+          [clientHeight - prevPageState.bottomSafeArea, clientHeight - pageState.bottomSafeArea]
+        ),
+        height: transProgress.to([0, 1], [prevPageState.bottomSafeArea, pageState.bottomSafeArea])
+      }
+    },
+    page: {
+      containerStyle: {},
+      contentStyle: {
+        paddingTop: pageState.topSafeArea + pageState.topInset,
+        paddingBottom: pageState.bottomInset + pageState.bottomSafeArea,
+        translateX: transUnit,
+        height: clientHeight
+      }
+    },
+    prevPage: {
+      containerStyle: {
+        paddingTop: prevPageState.topSafeArea + prevPageState.topInset,
+        translateX: transUnit.to((unit) => (unit - clientWidth) / 5)
+      },
+      contentStyle: {
+        opacity: transProgress.to((progress) => 1 - progress / 2)
+      }
+    },
+    topInset: {
+      containerStyle: {
+        top: transProgress.to([0, 1], [prevPageState.topSafeArea, pageState.topSafeArea]),
+        height: transProgress.to([0, 1], [prevPageState.topInset, pageState.topInset])
+      },
+      contentStyle: {
+        opacity: transProgress.to((progress) => progress),
+        translateX: transProgress.to([0, 1], [clientWidth / 5, 0])
+      },
+      prevContentStyle: {
+        opacity: transProgress.to((progress) => 1 - progress),
+        translateX: transProgress.to([0, 1], [0, -clientWidth / 5])
+      }
+    },
+    topLeftAction: {
+      containerStyle: {
+        top: transProgress.to([0, 1], [prevPageState.topSafeArea, pageState.topSafeArea]),
+        height: transProgress.to([0, 1], [prevPageState.topInset, pageState.topInset]),
+        minWidth: transProgress.to([0, 1], [prevPageState.topInset, pageState.topInset])
+      },
+      contentStyle: {
+        opacity: transProgress.to((progress) => progress)
+      },
+      prevContentStyle: {
+        opacity: transProgress.to((progress) => 1 - progress)
+      }
+    },
+    bottomInset: {
+      containerStyle: {
+        height: transProgress.to([0, 1], [prevPageState.bottomInset, pageState.bottomInset]),
+        top: transProgress.to(
+          [0, 1],
+          [
+            clientHeight - prevPageState.bottomInset - prevPageState.bottomSafeArea,
+            clientHeight - pageState.bottomInset - pageState.bottomSafeArea
+          ]
+        )
+      },
+      contentStyle: {
+        top: transProgress.to([0, 1], [0, -(pageState.bottomInset - prevPageState.bottomInset) * 2]),
+        opacity: transProgress.to((progress) => progress)
+      },
+      prevContentStyle: {
+        top: transProgress.to([0, 1], [0, -(pageState.bottomInset - prevPageState.bottomInset) * 2]),
+        opacity: transProgress.to((progress) => 1 - progress)
+      }
+    }
+  };
+  const useCsrTransition = {
+    ...csrTranstionStyles,
+    pageBind,
+    pageClassName,
+    transDirection,
+    transUnitRange,
+    transUnit,
+    transPercent,
+    transProgress
+  };
+  return useCsrTransition;
+};
+const useBottomUpTrans = ({
+  clientWidth,
+  clientHeight,
+  history,
+  location,
+  prevLocation,
+  onBack
+}) => {
+  const transDirection = "vertical";
+  const transUnit = useSpringValue(0, { config: { clamp: true } });
+  const transUnitRange = useMemo(() => [clientHeight, 0], []);
+  const transUnitReversed = transUnit.to((unit) => transUnitRange[0] - unit);
+  const transUnitRangeReversed = useMemo(() => [0, clientWidth], []);
+  const transProgress = transUnitReversed.to(transUnitRangeReversed, [0, 1], "clamp");
+  const transPercent = transUnitReversed.to(transUnitRangeReversed, [0, 100], "clamp");
+  const initThreshold = useMemo(() => Math.floor(clientWidth / 3), []);
+  const threshold = useMemo(() => Math.floor(clientWidth / 2), []);
+  const pageState = location.pathRoute.pageState;
+  const prevPageState = prevLocation?.pathRoute.pageState ?? defaultPageState;
+  useEffect(() => {
+    onBack.current.bottomUp = async () => {
+      await transUnit.start(transUnitRange[0]);
+    };
+  }, []);
+  useEffect(() => {
+    if (history.current.type === "forward") {
+      void transUnit.start(transUnitRange[0], { immediate: true });
+      void transUnit.start(transUnitRange[1], { config: { duration: 150 } });
+    } else {
+      void transUnit.start(transUnitRange[1], { immediate: true });
+      return;
+    }
+  }, [location.pathname]);
+  const pageBind = useDrag(
+    ({ first, last, movement: [, my], initial: [, iy], cancel }) => {
+      if (first)
+        void device.hideKeyboard();
+      if (iy > initThreshold) {
+        cancel();
+        return;
+      }
+      if (my < transUnitRange[1])
+        void transUnit.start(transUnitRange[1], { immediate: true });
+      else if (my > transUnitRange[0])
+        void transUnit.start(transUnitRange[0], { immediate: true });
+      else if (!last)
+        void transUnit.start(my, { immediate: true });
+      else if (my < threshold)
+        void transUnit.start(transUnitRange[1]);
+      if (last && my > threshold)
+        router.back();
+    },
+    { axis: "y", filterTaps: true, threshold: 10 }
+  );
+  const csrTranstionStyles = {
+    topSafeArea: {
+      containerStyle: {
+        height: transProgress.to([0, 1], [prevPageState.topSafeArea, pageState.topSafeArea])
+      }
+    },
+    bottomSafeArea: {
+      containerStyle: {
+        top: transProgress.to(
+          [0, 1],
+          [clientHeight - prevPageState.bottomSafeArea, clientHeight - pageState.bottomSafeArea]
+        ),
+        height: transProgress.to([0, 1], [prevPageState.bottomSafeArea, pageState.bottomSafeArea])
+      }
+    },
+    page: {
+      containerStyle: {},
+      contentStyle: {
+        paddingTop: pageState.topSafeArea + pageState.topInset,
+        paddingBottom: pageState.bottomInset + pageState.bottomSafeArea,
+        translateY: transUnit,
+        height: clientHeight
+      }
+    },
+    prevPage: {
+      containerStyle: {
+        paddingTop: prevPageState.topSafeArea + prevPageState.topInset,
+        translateY: 0
+      },
+      contentStyle: {
+        opacity: transProgress.to((progress) => 1 - progress / 2)
+      }
+    },
+    topInset: {
+      containerStyle: {
+        top: transProgress.to([0, 1], [prevPageState.topSafeArea, pageState.topSafeArea]),
+        height: transProgress.to([0, 1], [prevPageState.topInset, pageState.topInset])
+      },
+      contentStyle: {
+        opacity: transProgress.to((progress) => progress)
+        // translateX: transProgress.to([0, 1], [clientWidth / 5, 0]),
+      },
+      prevContentStyle: {
+        opacity: transProgress.to((progress) => 1 - progress)
+        // translateX: transProgress.to([0, 1], [0, -clientWidth / 5]),
+      }
+    },
+    topLeftAction: {
+      containerStyle: {
+        top: transProgress.to([0, 1], [prevPageState.topSafeArea, pageState.topSafeArea]),
+        height: transProgress.to([0, 1], [prevPageState.topInset, pageState.topInset])
+      },
+      contentStyle: {
+        opacity: transProgress.to((progress) => progress)
+      },
+      prevContentStyle: {
+        opacity: transProgress.to((progress) => 1 - progress)
+      }
+    },
+    bottomInset: {
+      containerStyle: {
+        height: transProgress.to([0, 1], [prevPageState.bottomInset, pageState.bottomInset]),
+        top: transProgress.to(
+          [0, 1],
+          [
+            clientHeight - prevPageState.bottomInset - prevPageState.bottomSafeArea,
+            clientHeight - pageState.bottomInset - pageState.bottomSafeArea
+          ]
+        )
+      },
+      contentStyle: {
+        top: transProgress.to([0, 1], [0, -(pageState.bottomInset - prevPageState.bottomInset) * 2]),
+        opacity: transProgress.to((progress) => progress)
+      },
+      prevContentStyle: {
+        top: transProgress.to([0, 1], [0, -(pageState.bottomInset - prevPageState.bottomInset) * 2]),
+        opacity: transProgress.to((progress) => 1 - progress)
+      }
+    }
+  };
+  const useCsrTransition = {
+    ...csrTranstionStyles,
+    pageBind,
+    pageClassName: "touch-pan-x",
+    transDirection,
+    transUnitRange,
+    transUnit,
+    transPercent,
+    transProgress
+  };
+  return useCsrTransition;
+};
+const useCsrValues = (rootRouteGuide, pathRoutes) => {
+  const clientWidth = useRef(window.innerWidth);
+  const clientHeight = useRef(window.innerHeight);
+  const topSafeAreaRef = useRef(null);
+  const bottomSafeAreaRef = useRef(null);
+  const pageContentRef = useRef(null);
+  const prevPageContentRef = useRef(null);
+  const onBack = useRef({});
+  const frameRootRef = useRef(null);
+  const { getLocation } = useLocation({ rootRouteGuide });
+  const { history, setHistoryForward, setHistoryBack, getCurrentLocation, getPrevLocation, getScrollTop } = useHistory([
+    getLocation(window.location.pathname)
+  ]);
+  const [{ location, prevLocation }, setLocationState] = useState({
+    location: getCurrentLocation(),
+    prevLocation: getPrevLocation()
+  });
+  const getRouter = useCallback(() => {
+    const router3 = {
+      push: (href) => {
+        const location2 = getCurrentLocation();
+        const scrollTop = pageContentRef.current?.scrollTop ?? 0;
+        setHistoryForward({ type: "push", location: getLocation(href), scrollTop });
+        setLocationState({ location: getCurrentLocation(), prevLocation: location2 });
+        window.history.pushState({}, "", href);
+      },
+      replace: (href) => {
+        const scrollTop = pageContentRef.current?.scrollTop ?? 0;
+        setHistoryForward({ type: "replace", location: getLocation(href), scrollTop });
+        setLocationState({ location: getCurrentLocation(), prevLocation });
+        window.history.replaceState({}, "", href);
+      },
+      refresh: () => {
+        window.location.reload();
+      },
+      back: async () => {
+        const location2 = getCurrentLocation();
+        await onBack.current[location2.pathRoute.pageState.transition]?.();
+        const scrollTop = pageContentRef.current?.scrollTop ?? 0;
+        setHistoryBack({ type: "back", location: location2, scrollTop });
+        setLocationState({ location: getCurrentLocation(), prevLocation: getPrevLocation() });
+        window.history.back();
+      }
+    };
+    window.onpopstate = async (ev) => {
+      const routeType = window.location.pathname === getCurrentLocation().pathname && history.current.type !== "back" ? "forward" : window.location.pathname === getPrevLocation()?.pathname ? "back" : null;
+      const scrollTop = pageContentRef.current?.scrollTop ?? 0;
+      if (!routeType)
+        return;
+      if (routeType === "forward") {
+        const location2 = getCurrentLocation();
+        setHistoryForward({ type: "popForward", location: location2, scrollTop });
+        setLocationState({ location: getCurrentLocation(), prevLocation: location2 });
+      } else {
+        const location2 = getCurrentLocation();
+        await onBack.current[location2.pathRoute.pageState.transition]?.();
+        setHistoryBack({ type: "popBack", location: location2, scrollTop });
+        setLocationState({ location: getCurrentLocation(), prevLocation: getPrevLocation() });
+      }
+    };
+    return router3;
+  }, [location]);
+  const router2 = getRouter();
+  const routeState = {
+    clientWidth: clientWidth.current,
+    clientHeight: clientHeight.current,
+    location,
+    prevLocation,
+    history,
+    topSafeAreaRef,
+    bottomSafeAreaRef,
+    prevPageContentRef,
+    pageContentRef,
+    frameRootRef,
+    onBack,
+    router: router2,
+    pathRoutes
+  };
+  const useNonTransition = useNoneTrans(routeState);
+  const useFadeTransition = useFadeTrans(routeState);
+  const useStackTransition = useStackTrans(routeState);
+  const useBottomUpTransition = useBottomUpTrans(routeState);
+  const useCsrTransitionMap = {
+    none: useNonTransition,
+    fade: useFadeTransition,
+    stack: useStackTransition,
+    bottomUp: useBottomUpTransition,
+    scaleOut: useNonTransition
+  };
+  useEffect(() => {
+    if (pageContentRef.current)
+      pageContentRef.current.scrollTop = getScrollTop(location.pathname);
+    if (prevPageContentRef.current)
+      prevPageContentRef.current.scrollTop = prevLocation ? getScrollTop(prevLocation.pathname) : 0;
+    void App.addListener("backButton", () => {
+      router2.back();
+    });
+    return () => {
+      void App.removeAllListeners();
+    };
+  }, [location.pathname]);
+  return {
+    ...routeState,
+    ...useCsrTransitionMap[location.pathRoute.pageState.transition]
+  };
+};
+export {
+  useCsrValues
+};

package/useDebounce.mjs

@@ -0,0 +1,18 @@
+"use client";
+import { useCallback } from "react";
+const debounce = (callback, wait = 500) => {
+  let timer;
+  return (...args) => {
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      callback(...args);
+    }, wait);
+  };
+};
+const useDebounce = (callback, states = [], wait = 100) => {
+  const fn = useCallback(debounce(callback, wait), states);
+  return fn;
+};
+export {
+  useDebounce
+};

package/useFetch.mjs

@@ -0,0 +1,23 @@
+"use client";
+import { useEffect, useState } from "react";
+const useFetch = (fnOrPromise, { onError } = {}) => {
+  const [fetchState, setFetchState] = useState(
+    fnOrPromise instanceof Promise ? { fulfilled: false, value: null } : { fulfilled: true, value: fnOrPromise }
+  );
+  useEffect(() => {
+    void (async () => {
+      try {
+        const ret = fnOrPromise instanceof Promise ? await fnOrPromise : fnOrPromise;
+        setFetchState({ fulfilled: true, value: ret });
+      } catch (err) {
+        const content = `Error: ${typeof err === "string" ? err : err.message}`;
+        onError?.(content);
+        throw new Error(content);
+      }
+    })();
+  }, []);
+  return fetchState;
+};
+export {
+  useFetch
+};

package/useGeoLocation.mjs

@@ -0,0 +1,21 @@
+"use client";
+import { Geolocation } from "@capacitor/geolocation";
+const useGeoLocation = () => {
+  const checkPermission = async () => {
+    const { location: geolocation, coarseLocation } = await Geolocation.requestPermissions();
+    return { geolocation, coarseLocation };
+  };
+  const getPosition = async () => {
+    const { geolocation, coarseLocation } = await checkPermission();
+    if (geolocation === "denied" || coarseLocation === "denied") {
+      location.assign("app-settings:");
+      return;
+    }
+    const coordinates = await Geolocation.getCurrentPosition();
+    return coordinates;
+  };
+  return { checkPermission, getPosition };
+};
+export {
+  useGeoLocation
+};