@akanjs/next 0.0.39 → 0.0.40

package/src/useDebounce.d.ts

@@ -0,0 +1,3 @@
+declare const useDebounce: <Callback extends (...args: any) => any>(callback: Callback, states?: any[], wait?: number) => Callback;
+
+export { useDebounce };

package/src/useDebounce.js

@@ -0,0 +1,42 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 useDebounce_exports = {};
+__export(useDebounce_exports, {
+  useDebounce: () => useDebounce
+});
+module.exports = __toCommonJS(useDebounce_exports);
+var import_react = require("react");
+const debounce = /* @__PURE__ */ __name((callback, wait = 500) => {
+  let timer;
+  return (...args) => {
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      callback(...args);
+    }, wait);
+  };
+}, "debounce");
+const useDebounce = /* @__PURE__ */ __name((callback, states = [], wait = 100) => {
+  const fn = (0, import_react.useCallback)(debounce(callback, wait), states);
+  return fn;
+}, "useDebounce");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useDebounce
+});

package/src/useFetch.d.ts

@@ -0,0 +1,8 @@
+declare const useFetch: <Return>(fnOrPromise: Promise<Return> | Return, { onError }?: {
+    onError?: (err: string) => void;
+}) => {
+    fulfilled: boolean;
+    value: Return | null;
+};
+
+export { useFetch };

package/src/useFetch.js

@@ -0,0 +1,54 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 = /* @__PURE__ */ __name((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;
+}, "useFetch");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useFetch
+});

package/src/useGeoLocation.d.ts

@@ -0,0 +1,12 @@
+import * as _capacitor_geolocation from '@capacitor/geolocation';
+import * as _capacitor_core from '@capacitor/core';
+
+declare const useGeoLocation: () => {
+    checkPermission: () => Promise<{
+        geolocation: _capacitor_core.PermissionState;
+        coarseLocation: _capacitor_core.PermissionState;
+    }>;
+    getPosition: () => Promise<_capacitor_geolocation.Position | undefined>;
+};
+
+export { useGeoLocation };

package/src/useGeoLocation.js

@@ -0,0 +1,51 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 useGeoLocation_exports = {};
+__export(useGeoLocation_exports, {
+  useGeoLocation: () => useGeoLocation
+});
+module.exports = __toCommonJS(useGeoLocation_exports);
+var import_geolocation = require("@capacitor/geolocation");
+const useGeoLocation = /* @__PURE__ */ __name(() => {
+  const checkPermission = /* @__PURE__ */ __name(async () => {
+    const { location: geolocation, coarseLocation } = await import_geolocation.Geolocation.requestPermissions();
+    return {
+      geolocation,
+      coarseLocation
+    };
+  }, "checkPermission");
+  const getPosition = /* @__PURE__ */ __name(async () => {
+    const { geolocation, coarseLocation } = await checkPermission();
+    if (geolocation === "denied" || coarseLocation === "denied") {
+      location.assign("app-settings:");
+      return;
+    }
+    const coordinates = await import_geolocation.Geolocation.getCurrentPosition();
+    return coordinates;
+  }, "getPosition");
+  return {
+    checkPermission,
+    getPosition
+  };
+}, "useGeoLocation");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useGeoLocation
+});

package/src/useHistory.d.ts

@@ -0,0 +1,24 @@
+import * as react from 'react';
+import { L as Location, H as History } from '../csrTypes-B6ATv9-y.js';
+import 'react-spring';
+
+interface setForwardOptions {
+    type: "push" | "replace" | "popForward";
+    location: Location;
+    scrollTop?: number;
+}
+interface setBackOptions {
+    type: "back" | "popBack";
+    location: Location;
+    scrollTop?: number;
+}
+declare const useHistory: (locations?: Location[]) => {
+    history: react.MutableRefObject<History>;
+    setHistoryForward: ({ type, location, scrollTop }: setForwardOptions) => void;
+    setHistoryBack: ({ location, scrollTop }: setBackOptions) => void;
+    getCurrentLocation: () => Location;
+    getPrevLocation: () => Location | null;
+    getScrollTop: (pathname?: string) => number;
+};
+
+export { useHistory };

package/src/useHistory.js

@@ -0,0 +1,88 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 = /* @__PURE__ */ __name((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[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
+  };
+}, "useHistory");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useHistory
+});

package/src/useInterval.d.ts

@@ -0,0 +1,5 @@
+import * as react from 'react';
+
+declare const useInterval: (callback: (() => void) | (() => Promise<void>), delay: number) => react.MutableRefObject<(() => void) | (() => Promise<void>) | null>;
+
+export { useInterval };

package/src/useInterval.js

@@ -0,0 +1,49 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 = /* @__PURE__ */ __name((callback, delay) => {
+  const savedCallback = (0, import_react.useRef)(null);
+  (0, import_react.useEffect)(() => {
+    savedCallback.current = callback;
+  }, [
+    callback
+  ]);
+  (0, import_react.useEffect)(() => {
+    const tick = /* @__PURE__ */ __name(() => {
+      void savedCallback.current?.();
+    }, "tick");
+    const id = setInterval(tick, delay);
+    return () => {
+      clearInterval(id);
+    };
+  }, [
+    delay
+  ]);
+  return savedCallback;
+}, "useInterval");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useInterval
+});

package/src/useLocation.d.ts

@@ -0,0 +1,12 @@
+import { R as RouteGuide, L as Location } from '../csrTypes-B6ATv9-y.js';
+import 'react';
+import 'react-spring';
+
+interface UseLocationOptions {
+    rootRouteGuide: RouteGuide;
+}
+declare const useLocation: ({ rootRouteGuide }: UseLocationOptions) => {
+    getLocation: (href: string) => Location;
+};
+
+export { useLocation };

package/src/useLocation.js

@@ -0,0 +1,92 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 = /* @__PURE__ */ __name(({ rootRouteGuide }) => {
+  const getLocation = (0, import_react.useCallback)((href) => {
+    const getPathSegments = /* @__PURE__ */ __name((pathname2) => {
+      return [
+        ...pathname2.split("/").filter((pathSegment) => !!pathSegment).map((pathSegment) => `/${pathSegment}`)
+      ];
+    }, "getPathSegments");
+    const getPathRoute = /* @__PURE__ */ __name((pathname2) => {
+      const pathSegments = getPathSegments(pathname2);
+      const getTargetRouteGuide = /* @__PURE__ */ __name((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);
+      }, "getTargetRouteGuide");
+      const targetRouteGuide = getTargetRouteGuide(pathSegments, rootRouteGuide);
+      const pathRoute2 = targetRouteGuide.pathRoute;
+      if (!pathRoute2) {
+        window.location.assign("/404");
+        throw new Error("404");
+      }
+      return pathRoute2;
+    }, "getPathRoute");
+    const getParams = /* @__PURE__ */ __name((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;
+      }, {});
+    }, "getParams");
+    const getSearchParams = /* @__PURE__ */ __name((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;
+      }, {});
+    }, "getSearchParams");
+    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
+  };
+}, "useLocation");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useLocation
+});

package/src/usePurchase.d.ts

@@ -0,0 +1,20 @@
+type PlatformType = "android" | "ios" | "all";
+interface ProductType {
+    id: string;
+    type: keyof typeof CdvPurchase.ProductType;
+}
+type CdvProductType = CdvPurchase.ProductType;
+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>;
+};
+
+export { type CdvProductType, type PlatformType, type ProductType, usePurchase };

package/src/usePurchase.js

@@ -0,0 +1,139 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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 usePurchase_exports = {};
+__export(usePurchase_exports, {
+  usePurchase: () => usePurchase
+});
+module.exports = __toCommonJS(usePurchase_exports);
+var import_store = require("cordova-plugin-purchase/www/store");
+var import_app = require("@capacitor/app");
+var import_react = require("react");
+const usePurchase = /* @__PURE__ */ __name(({ platform, productInfo, url, onPay, onSubscribe }) => {
+  const [isLoading, setIsLoading] = (0, import_react.useState)(true);
+  const billingRef = (0, import_react.useRef)();
+  (0, import_react.useEffect)(() => {
+    const init = /* @__PURE__ */ __name(async () => {
+      if (CdvPurchase.store.isReady) {
+        setIsLoading(false);
+        return;
+      }
+      const app = await import_app.App.getInfo();
+      if (platform === "all") CdvPurchase.store.register([
+        ...productInfo.map((prouct) => ({
+          id: prouct.id,
+          platform: CdvPurchase.Platform.GOOGLE_PLAY,
+          type: CdvPurchase.ProductType[prouct.type]
+        })),
+        ...productInfo.map((prouct) => ({
+          id: prouct.id,
+          platform: CdvPurchase.Platform.APPLE_APPSTORE,
+          type: CdvPurchase.ProductType[prouct.type]
+        }))
+      ]);
+      else CdvPurchase.store.register(productInfo.map((product) => ({
+        id: product.id,
+        platform: platform === "android" ? CdvPurchase.Platform.GOOGLE_PLAY : CdvPurchase.Platform.APPLE_APPSTORE,
+        type: CdvPurchase.ProductType[product.type]
+      })));
+      await CdvPurchase.store.initialize([
+        {
+          platform: CdvPurchase.Platform.APPLE_APPSTORE,
+          options: {
+            needAppReceipt: false
+          }
+        },
+        {
+          platform: CdvPurchase.Platform.GOOGLE_PLAY
+        }
+      ]);
+      await CdvPurchase.store.update();
+      await CdvPurchase.store.restorePurchases();
+      CdvPurchase.store.validator = async (request, callback) => {
+        const transactionId = request.transaction.id;
+        const transactions = CdvPurchase.store.localTransactions;
+        const verifingTransaction = transactions.find((transaction) => transaction.transactionId === transactionId);
+        if (verifingTransaction?.state !== "approved") return;
+        const billing = await fetch(`${url}/billing/verifyBilling`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            data: {
+              platform: verifingTransaction.platform === CdvPurchase.Platform.GOOGLE_PLAY ? "google" : "apple",
+              packageName: app.id,
+              productId: verifingTransaction.products[0].id,
+              receipt: verifingTransaction.platform === CdvPurchase.Platform.GOOGLE_PLAY ? request.transaction.purchaseToken : request.transaction.appStoreReceipt,
+              transactionId: verifingTransaction.transactionId
+            }
+          })
+        });
+        billingRef.current = billing.json();
+        callback({
+          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+          ok: billing ? true : false,
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          data: {
+            id: request.id,
+            latest_receipt: true,
+            transaction: request.transaction
+          }
+        });
+      };
+      if (CdvPurchase.store.localReceipts.length > 0) {
+        CdvPurchase.store.localReceipts.forEach((receipt) => {
+          if (receipt.platform === CdvPurchase.Platform.GOOGLE_PLAY) if (receipt.transactions[0].state === CdvPurchase.TransactionState.APPROVED) void receipt.transactions[0].verify();
+          else void receipt.transactions[0].finish();
+        });
+      }
+      CdvPurchase.store.when().approved((transaction) => {
+        void transaction.verify();
+      }).verified((receipt) => {
+        void receipt.finish();
+      }).finished((transaction) => {
+        void inAppPurchase(transaction);
+      });
+      setIsLoading(false);
+    }, "init");
+    void init();
+  }, []);
+  const purchaseProduct = /* @__PURE__ */ __name(async (product) => {
+    await product.getOffer()?.order();
+  }, "purchaseProduct");
+  const restorePurchases = /* @__PURE__ */ __name(async () => {
+    await CdvPurchase.store.restorePurchases();
+  }, "restorePurchases");
+  const inAppPurchase = /* @__PURE__ */ __name(async (transaction) => {
+    const product = CdvPurchase.store.get(transaction.products[0].id);
+    if (product?.type === "consumable") await onPay?.(transaction);
+    else await onSubscribe?.(transaction);
+    await transaction.finish();
+  }, "inAppPurchase");
+  return {
+    isLoading,
+    products: CdvPurchase.store.products,
+    purchaseProduct,
+    restorePurchases
+  };
+}, "usePurchase");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  usePurchase
+});

package/src/usePushNoti.d.ts

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