@akanjs/next 0.0.4

package/src/useFetch.js

@@ -0,0 +1,46 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useFetch_exports = {};
+__export(useFetch_exports, {
+  useFetch: () => useFetch
+});
+module.exports = __toCommonJS(useFetch_exports);
+var import_react = require("react");
+const useFetch = (fnOrPromise, { onError } = {}) => {
+  const [fetchState, setFetchState] = (0, import_react.useState)(
+    fnOrPromise instanceof Promise ? { fulfilled: false, value: null } : { fulfilled: true, value: fnOrPromise }
+  );
+  (0, import_react.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;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useFetch
+});

package/src/useGeoLocation.d.ts

@@ -0,0 +1,7 @@
+export declare const useGeoLocation: () => {
+    checkPermission: () => Promise<{
+        geolocation: import("@capacitor/core").PermissionState;
+        coarseLocation: import("@capacitor/core").PermissionState;
+    }>;
+    getPosition: () => Promise<import("@capacitor/geolocation").Position | undefined>;
+};

package/src/useHistory.d.ts

@@ -0,0 +1,20 @@
+import type { History, Location } from "@akanjs/client";
+interface setForwardOptions {
+    type: "push" | "replace" | "popForward";
+    location: Location;
+    scrollTop?: number;
+}
+interface setBackOptions {
+    type: "back" | "popBack";
+    location: Location;
+    scrollTop?: number;
+}
+export declare const useHistory: (locations?: Location[]) => {
+    history: import("react").MutableRefObject<History>;
+    setHistoryForward: ({ type, location, scrollTop }: setForwardOptions) => void;
+    setHistoryBack: ({ location, scrollTop }: setBackOptions) => void;
+    getCurrentLocation: () => Location;
+    getPrevLocation: () => Location | null;
+    getScrollTop: (pathname?: string) => number;
+};
+export {};

package/src/useHistory.js

@@ -0,0 +1,69 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useHistory_exports = {};
+__export(useHistory_exports, {
+  useHistory: () => useHistory
+});
+module.exports = __toCommonJS(useHistory_exports);
+var import_react = require("react");
+const useHistory = (locations = []) => {
+  const history = (0, import_react.useRef)({
+    type: "initial",
+    locations,
+    scrollMap: /* @__PURE__ */ new Map([[window.location.pathname, 0]]),
+    idxMap: /* @__PURE__ */ new Map([[window.location.pathname, 0]]),
+    cachedLocationMap: /* @__PURE__ */ new Map(),
+    idx: 0
+  });
+  const setHistoryForward = (0, import_react.useCallback)(({ type, location, scrollTop = 0 }) => {
+    history.current.type = "forward";
+    history.current.scrollMap.set(location.pathname, scrollTop);
+    history.current.idxMap.set(location.pathname, history.current.idx);
+    if (type === "push")
+      history.current.locations = [...history.current.locations.slice(0, history.current.idx + 1), location];
+    else if (type === "replace")
+      history.current.locations = [...history.current.locations.slice(0, history.current.idx), location];
+    if (location.pathRoute.pageState.cache)
+      history.current.cachedLocationMap.set(location.pathRoute.path, location);
+    if (type === "push" || type === "popForward")
+      history.current.idx++;
+  }, []);
+  const setHistoryBack = (0, import_react.useCallback)(({ location, scrollTop = 0 }) => {
+    history.current.type = "back";
+    history.current.scrollMap.set(location.pathname, scrollTop);
+    history.current.idxMap.set(location.pathname, history.current.idx);
+    if (location.pathRoute.pageState.cache)
+      history.current.cachedLocationMap.set(location.pathRoute.path, location);
+    history.current.idx--;
+  }, []);
+  const getCurrentLocation = (0, import_react.useCallback)(() => {
+    return history.current.locations[history.current.idx];
+  }, []);
+  const getPrevLocation = (0, import_react.useCallback)(() => {
+    return history.current.locations.at(history.current.idx - 1) ?? null;
+  }, []);
+  const getScrollTop = (0, import_react.useCallback)((pathname = history.current.locations[history.current.idx]?.pathname ?? "/") => {
+    return history.current.scrollMap.get(pathname) ?? 0;
+  }, []);
+  return { history, setHistoryForward, setHistoryBack, getCurrentLocation, getPrevLocation, getScrollTop };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useHistory
+});

package/src/useInterval.d.ts

@@ -0,0 +1 @@
+export declare const useInterval: (callback: (() => void) | (() => Promise<void>), delay: number) => import("react").MutableRefObject<(() => void) | (() => Promise<void>) | null>;

package/src/useInterval.js

@@ -0,0 +1,44 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useInterval_exports = {};
+__export(useInterval_exports, {
+  useInterval: () => useInterval
+});
+module.exports = __toCommonJS(useInterval_exports);
+var import_react = require("react");
+const useInterval = (callback, delay) => {
+  const savedCallback = (0, import_react.useRef)(null);
+  (0, import_react.useEffect)(() => {
+    savedCallback.current = callback;
+  }, [callback]);
+  (0, import_react.useEffect)(() => {
+    const tick = () => {
+      void savedCallback.current?.();
+    };
+    const id = setInterval(tick, delay);
+    return () => {
+      clearInterval(id);
+    };
+  }, [delay]);
+  return savedCallback;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useInterval
+});

package/src/useLocation.d.ts

@@ -0,0 +1,8 @@
+import { type Location, type RouteGuide } from "@akanjs/client";
+interface UseLocationOptions {
+    rootRouteGuide: RouteGuide;
+}
+export declare const useLocation: ({ rootRouteGuide }: UseLocationOptions) => {
+    getLocation: (href: string) => Location;
+};
+export {};

package/src/useLocation.js

@@ -0,0 +1,82 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useLocation_exports = {};
+__export(useLocation_exports, {
+  useLocation: () => useLocation
+});
+module.exports = __toCommonJS(useLocation_exports);
+var import_react = require("react");
+const useLocation = ({ rootRouteGuide }) => {
+  const getLocation = (0, import_react.useCallback)((href) => {
+    const getPathSegments = (pathname2) => {
+      return [
+        ...pathname2.split("/").filter((pathSegment) => !!pathSegment).map((pathSegment) => `/${pathSegment}`)
+      ];
+    };
+    const getPathRoute = (pathname2) => {
+      const pathSegments = getPathSegments(pathname2);
+      const getTargetRouteGuide = (pathSegments2, routeGuide) => {
+        const pathSegment = pathSegments2.shift();
+        if (!pathSegment)
+          return routeGuide;
+        const childrenSegments = Object.keys(routeGuide.children);
+        const matchingPathSegment = childrenSegments.find((segment) => segment === pathSegment);
+        const paramSegment = childrenSegments.find((segment) => segment.startsWith("/:"));
+        const childRouteGuide = matchingPathSegment ? routeGuide.children[pathSegment] : paramSegment ? routeGuide.children[paramSegment] : null;
+        if (!childRouteGuide)
+          throw new Error("404");
+        return getTargetRouteGuide(pathSegments2, childRouteGuide);
+      };
+      const targetRouteGuide = getTargetRouteGuide(pathSegments, rootRouteGuide);
+      const pathRoute2 = targetRouteGuide.pathRoute;
+      if (!pathRoute2) {
+        window.location.assign("/404");
+        throw new Error("404");
+      }
+      return pathRoute2;
+    };
+    const getParams = (pathname2, pathRoute2) => {
+      const pathSegments = getPathSegments(pathname2);
+      return pathRoute2.pathSegments.reduce((params2, pathSegment, idx) => {
+        if (pathSegment.startsWith("/:"))
+          params2[pathSegment.slice(2)] = pathSegments[idx - 1].slice(1);
+        return params2;
+      }, {});
+    };
+    const getSearchParams = (search2) => {
+      return [...new URLSearchParams(search2).entries()].reduce(
+        (params2, [key, value]) => {
+          params2[key] = params2[key] ? [...Array.isArray(params2[key]) ? params2[key] : [params2[key]], value] : value;
+          return params2;
+        },
+        {}
+      );
+    };
+    const [pathname, search] = href.split("?");
+    const pathRoute = getPathRoute(pathname);
+    const params = getParams(pathname, pathRoute);
+    const searchParams = getSearchParams(search);
+    return { pathname, search, params, searchParams, pathRoute };
+  }, []);
+  return { getLocation };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useLocation
+});

package/src/usePurchase.d.ts

@@ -0,0 +1,19 @@
+import "cordova-plugin-purchase/www/store";
+export type PlatformType = "android" | "ios" | "all";
+export interface ProductType {
+    id: string;
+    type: keyof typeof CdvPurchase.ProductType;
+}
+export type CdvProductType = CdvPurchase.ProductType;
+export declare const usePurchase: ({ platform, productInfo, url, onPay, onSubscribe, }: {
+    platform: PlatformType;
+    productInfo: ProductType[];
+    url: string;
+    onPay?: (transaction: CdvPurchase.Transaction) => void | Promise<void>;
+    onSubscribe?: (transaction: CdvPurchase.Transaction) => void | Promise<void>;
+}) => {
+    isLoading: boolean;
+    products: CdvPurchase.Product[];
+    purchaseProduct: (product: CdvPurchase.Product) => Promise<void>;
+    restorePurchases: () => Promise<void>;
+};

package/src/usePushNoti.d.ts

@@ -0,0 +1,6 @@
+export declare const usePushNoti: () => {
+    init: () => Promise<void>;
+    checkPermission: () => Promise<boolean>;
+    register: () => Promise<void>;
+    getToken: () => Promise<string | undefined>;
+};

package/src/useThrottle.d.ts

@@ -0,0 +1 @@
+export declare const useThrottle: (func: (...args: any) => any, delay?: number, deps?: any[]) => (...args: any[]) => void;

package/src/useThrottle.js

@@ -0,0 +1,43 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useThrottle_exports = {};
+__export(useThrottle_exports, {
+  useThrottle: () => useThrottle
+});
+module.exports = __toCommonJS(useThrottle_exports);
+var import_react = require("react");
+const useThrottle = (func, delay = 200, deps = []) => {
+  const throttleSeed = (0, import_react.useRef)(null);
+  const throttleFunction = (0, import_react.useCallback)(
+    (...args) => {
+      if (throttleSeed.current)
+        return;
+      func(...args);
+      throttleSeed.current = setTimeout(() => {
+        throttleSeed.current = null;
+      }, delay);
+    },
+    [func, delay, ...deps]
+  );
+  return throttleFunction;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useThrottle
+});