akanjs 0.0.1 → 2.0.0-beta.0

package/webkit/useFetch.ts

@@ -0,0 +1,48 @@
+"use client";
+import { useEffect, useMemo, useState } from "react";
+
+/** Tracks fulfillment state for a promise or immediate value inside a client component. */
+export const useFetch = <Return>(
+  fnOrPromise: Promise<Return> | Return,
+  { onError }: { onError?: (err: string) => void } = {},
+): { fulfilled: boolean; value: Return | null } => {
+  const [asyncState, setAsyncState] = useState<{ fulfilled: boolean; value: Return | null }>({
+    fulfilled: false,
+    value: null,
+  });
+  useEffect(() => {
+    if (!(fnOrPromise instanceof Promise)) return;
+    let cancelled = false;
+    void (async () => {
+      try {
+        const ret = await fnOrPromise;
+        if (!cancelled) setAsyncState({ fulfilled: true, value: ret });
+      } catch (err) {
+        if (cancelled) return;
+        const content = `Error: ${typeof err === "string" ? err : (err as Error).message}`;
+        onError?.(content);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  if (!(fnOrPromise instanceof Promise)) {
+    return { fulfilled: true, value: fnOrPromise };
+  }
+  return asyncState;
+};
+
+/**
+ * Like `useFetch`, but takes a factory function that is only called once
+ * (or when `deps` change). Prevents duplicate network requests caused by
+ * React re-renders.
+ */
+export const useFetchFn = <Return>(
+  factory: () => Promise<Return> | Return,
+  deps: unknown[] = [],
+  options: { onError?: (err: string) => void } = {},
+): { fulfilled: boolean; value: Return | null } => {
+  const memoized = useMemo(factory, deps);
+  return useFetch(memoized, options);
+};

package/webkit/useGeoLocation.tsx

@@ -0,0 +1,24 @@
+"use client";
+import { loadCapacitorGeolocation } from "akanjs/client";
+
+/** Capacitor geolocation hook with permission checks and current position lookup. */
+export const useGeoLocation = () => {
+  const checkPermission = async (): Promise<{ geolocation: string; coarseLocation: string }> => {
+    const { Geolocation } = await loadCapacitorGeolocation();
+    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 { Geolocation } = await loadCapacitorGeolocation();
+    const coordinates = await Geolocation.getCurrentPosition();
+    return coordinates;
+  };
+
+  return { checkPermission, getPosition };
+};

package/webkit/useHistory.ts

@@ -0,0 +1,76 @@
+"use client";
+import type { History, Location } from "akanjs/client";
+import { useCallback, useRef } from "react";
+
+interface setForwardOptions {
+  type: "push" | "replace" | "popForward";
+  location: Location;
+  scrollTop?: number;
+  scrollToTop?: boolean;
+}
+
+interface setBackOptions {
+  type: "back" | "popBack";
+  location: Location;
+  scrollTop?: number;
+  scrollToTop?: boolean;
+}
+
+export const useHistory = (locations: Location[] = []) => {
+  const history = useRef<History>({
+    type: "initial",
+    locations,
+    scrollMap: new Map([[window.location.pathname, 0]]),
+    idxMap: new Map([[window.location.pathname, 0]]),
+    cachedLocationMap: new Map(),
+    idx: 0,
+  });
+  const setHistoryForward = useCallback(({ type, location, scrollTop = 0, scrollToTop = false }: setForwardOptions) => {
+    const currentLocation = history.current.locations[history.current.idx] as Location | undefined;
+    if (currentLocation) history.current.scrollMap.set(currentLocation.href, scrollTop);
+    if (scrollToTop) history.current.scrollMap.set(location.href, 0);
+    history.current.type = "forward";
+    history.current.idxMap.set(location.href, 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 = useCallback(({ location, scrollTop = 0, scrollToTop = false }: setBackOptions) => {
+    const prevLocation = history.current.locations[history.current.idx - 1] as Location | undefined;
+    if (prevLocation && scrollToTop) history.current.scrollMap.set(prevLocation.pathname, 0);
+    history.current.type = "back";
+    history.current.scrollMap.set(location.href, scrollTop);
+    history.current.idxMap.set(location.href, history.current.idx);
+    if (location.pathRoute.pageState.cache) history.current.cachedLocationMap.set(location.pathRoute.path, location);
+    history.current.idx--;
+  }, []);
+  const getNextLocation = useCallback(() => {
+    return (history.current.locations[history.current.idx + 1] ?? null) as Location | null;
+  }, []);
+  const getCurrentLocation = useCallback(() => {
+    return history.current.locations[history.current.idx];
+  }, []);
+  const getPrevLocation = useCallback(() => {
+    return (history.current.locations[history.current.idx - 1] ?? null) as Location | null;
+  }, []);
+  const getScrollTop = useCallback((location: Location) => {
+    if (location.hash) {
+      const element = window.document.getElementById(location.hash);
+      return element?.offsetTop ?? 0;
+    }
+    return history.current.scrollMap.get(location.href) ?? 0;
+  }, []);
+
+  return {
+    history,
+    setHistoryForward,
+    setHistoryBack,
+    getNextLocation,
+    getCurrentLocation,
+    getPrevLocation,
+    getScrollTop,
+  };
+};

package/webkit/useInterval.ts

@@ -0,0 +1,21 @@
+"use client";
+import { useEffect, useRef } from "react";
+
+/** Runs the latest callback repeatedly with the provided interval delay. */
+export const useInterval = (callback: (() => void) | (() => Promise<void>), delay: number) => {
+  const savedCallback = useRef<(() => void) | (() => Promise<void>) | null>(null);
+  useEffect(() => {
+    savedCallback.current = callback;
+  }, [callback]);
+  useEffect(() => {
+    const tick = () => {
+      void savedCallback.current?.();
+    };
+
+    const id = setInterval(tick, delay);
+    return () => {
+      clearInterval(id);
+    };
+  }, [delay]);
+  return savedCallback;
+};

package/webkit/useLocation.ts

@@ -0,0 +1,69 @@
+"use client";
+import type { Location, PathRoute, RouteGuide } from "akanjs/client";
+import { useCallback } from "react";
+
+interface UseLocationOptions {
+  rootRouteGuide: RouteGuide;
+}
+export const useLocation = ({ rootRouteGuide }: UseLocationOptions) => {
+  const getLocation = useCallback((href: string): Location => {
+    const getPathSegments = (pathname: string) => {
+      return [
+        ...pathname
+          .split("/")
+          .filter((pathSegment) => !!pathSegment)
+          .map((pathSegment) => `/${pathSegment}`),
+      ];
+    };
+    const getPathRoute = (pathname: string): PathRoute => {
+      const pathSegments = getPathSegments(pathname);
+      const getTargetRouteGuide = (pathSegments: string[], routeGuide: RouteGuide): RouteGuide => {
+        const pathSegment = pathSegments.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(`Not found: ${pathname}`);
+        return getTargetRouteGuide(pathSegments, childRouteGuide);
+      };
+      const targetRouteGuide = getTargetRouteGuide(pathSegments, rootRouteGuide);
+      const pathRoute = targetRouteGuide.pathRoute;
+      if (!pathRoute) {
+        window.location.assign("/404");
+        throw new Error("404");
+      }
+      return pathRoute;
+    };
+    const getParams = (pathname: string, pathRoute: PathRoute) => {
+      const pathSegments = getPathSegments(pathname);
+      return pathRoute.pathSegments.reduce<{ [key: string]: string }>((params, pathSegment, idx) => {
+        if (pathSegment.startsWith("/:")) params[pathSegment.slice(2)] = pathSegments[idx - 1].slice(1);
+        return params;
+      }, {});
+    };
+    const getSearchParams = (search: string) => {
+      return [...new URLSearchParams(search).entries()].reduce<{ [key: string]: string | string[] }>(
+        (params, [key, value]) => {
+          params[key] = (
+            params[key] ? [...(Array.isArray(params[key]) ? params[key] : [params[key]]), value] : value
+          ) as string | string[];
+          return params;
+        },
+        {},
+      );
+    };
+    const hrefWithoutOrigin = href.replace(window.location.origin, "");
+    const [hrefWithoutHash, hash = ""] = hrefWithoutOrigin.split("#");
+    const [pathname, search] = hrefWithoutHash.split("?");
+    const pathRoute = getPathRoute(pathname);
+    const params = getParams(pathname, pathRoute);
+    const searchParams = getSearchParams(search);
+    return { pathname, search, params, searchParams, pathRoute, hash, href };
+  }, []);
+  return { getLocation };
+};

package/webkit/usePurchase.tsx

@@ -0,0 +1,156 @@
+"use client";
+
+import "cordova-plugin-purchase/www/store";
+
+import { loadCapacitorApp } from "akanjs/client";
+import { useEffect, useRef, useState } from "react";
+
+export type PlatformType = "android" | "ios" | "all";
+export interface ProductType {
+  id: string;
+  type: keyof typeof CdvPurchase.ProductType;
+}
+
+export type CdvProductType = CdvPurchase.ProductType;
+
+export 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>;
+}) => {
+  const [isLoading, setIsLoading] = useState(true);
+  const billingRef = useRef<any>(null);
+
+  useEffect(() => {
+    const init = async () => {
+      if (CdvPurchase.store.isReady) {
+        setIsLoading(false);
+
+        return;
+      }
+      const { App } = await loadCapacitorApp();
+      const app = await 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: { id: string; transaction: { id: string; purchaseToken: string; appStoreReceipt: string } },
+        callback: (result: {
+          ok: boolean;
+          data: { id: string; latest_receipt: boolean; transaction: CdvPurchase.Transaction };
+        }) => void,
+      ) => {
+        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({
+          
+          ok: !!billing,
+          
+          data: { id: request.id, latest_receipt: true, transaction: request.transaction } as any,
+        });
+      }) as any;
+      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);
+    };
+    void init();
+  }, []);
+  const purchaseProduct = async (product: CdvPurchase.Product) => {
+    await product.getOffer()?.order();
+  };
+
+  const restorePurchases = async () => {
+    await CdvPurchase.store.restorePurchases();
+  };
+
+  const inAppPurchase = async (transaction: CdvPurchase.Transaction) => {
+    const product = CdvPurchase.store.get(transaction.products[0].id);
+    if (product?.type === "consumable") await onPay?.(transaction);
+    else await onSubscribe?.(transaction);
+    await transaction.finish();
+  };
+
+  return {
+    isLoading,
+    products: CdvPurchase.store.products,
+    purchaseProduct,
+    restorePurchases,
+  };
+};

package/webkit/usePushNoti.tsx

@@ -0,0 +1,48 @@
+"use client";
+import { loadCapacitorDevice, loadCapacitorFcm, loadCapacitorPushNotifications } from "akanjs/client";
+
+/** Capacitor push/FCM hook for permission, registration, and token retrieval. */
+export const usePushNoti = () => {
+  const init = async () => {
+    const [{ Device }, { FCM }, { PushNotifications }] = await Promise.all([
+      loadCapacitorDevice(),
+      loadCapacitorFcm(),
+      loadCapacitorPushNotifications(),
+    ]);
+    const device = await Device.getInfo();
+    if (device.platform === "web") return;
+    void FCM.setAutoInit({ enabled: true });
+    void PushNotifications.requestPermissions().then(async (result) => {
+      if (result.receive === "granted") {
+        await PushNotifications.register();
+      }
+    });
+  };
+
+  const checkPermission = async () => {
+    const { PushNotifications } = await loadCapacitorPushNotifications();
+    const { receive } = await PushNotifications.checkPermissions();
+    return receive === "granted";
+  };
+  const register = async () => {
+    const [{ Device }, { PushNotifications }] = await Promise.all([
+      loadCapacitorDevice(),
+      loadCapacitorPushNotifications(),
+    ]);
+    const device = await Device.getInfo();
+    if (device.platform === "web") return;
+    const { receive } = await PushNotifications.checkPermissions();
+
+    if (receive === "denied") location.assign("app-settings:");
+    else await PushNotifications.register();
+  };
+  const getToken = async () => {
+    const [{ Device }, { FCM }] = await Promise.all([loadCapacitorDevice(), loadCapacitorFcm()]);
+    const device = await Device.getInfo();
+    if (device.platform === "web") return;
+    const { token } = await FCM.getToken();
+    return token;
+  };
+
+  return { init, checkPermission, register, getToken };
+};

package/webkit/useThrottle.ts

@@ -0,0 +1,22 @@
+"use client";
+import { useCallback, useRef } from "react";
+
+/** Returns a callback that executes immediately, then ignores calls until delay passes. */
+export const useThrottle = <Args extends unknown[], Return>(
+  func: (...args: Args) => Return,
+  delay = 200,
+  deps: unknown[] = [],
+) => {
+  const throttleSeed = useRef<NodeJS.Timeout | null>(null);
+  const throttleFunction = useCallback(
+    (...args: Args) => {
+      if (throttleSeed.current) return;
+      func(...args);
+      throttleSeed.current = setTimeout(() => {
+        throttleSeed.current = null;
+      }, delay);
+    },
+    [func, delay, ...deps],
+  );
+  return throttleFunction;
+};

package/src/index.js

@@ -1,2 +0,0 @@
-export * from "./lib/akan2";
-//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../pkgs/akan/src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/src/lib/akan2.js

@@ -1,4 +0,0 @@
-export function akan2() {
-    return "akan2";
-}
-//# sourceMappingURL=akan2.js.map

package/src/lib/akan2.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"akan2.js","sourceRoot":"","sources":["../../../../../pkgs/akan/src/lib/akan2.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,KAAK;IACnB,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/src/run.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-// eslint-disable-next-line no-console
-console.log("run");
-//# sourceMappingURL=run.js.map

package/src/run.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"run.js","sourceRoot":"","sources":["../../../../pkgs/akan/src/run.ts"],"names":[],"mappings":"AAAA,sCAAsC;AACtC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC"}