akanjs 3.0.0-beta.20 → 3.0.0-beta.21

package/vendor/@akanjs/native/plugins/window-state/src/state.ts

@@ -0,0 +1,146 @@
+
+import type { SavedWindowState } from "./index.ts";
+
+/** The part of window.getState this plugin reads. */
+export interface WindowSnapshot {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  maximized: boolean;
+  minimized: boolean;
+  fullscreen: boolean;
+  visible: boolean;
+}
+
+const FORMAT = 1;
+/** Anything outside these bounds is a corrupt file, not a window. */
+const LIMIT = 1_000_000;
+
+const finite = (v: unknown, min: number): v is number =>
+  typeof v === "number" && Number.isFinite(v) && v >= min && v <= LIMIT;
+
+/** The saved file's contents, or null when it is missing, corrupt or from another format version. */
+export function parseSaved(text: string | null): SavedWindowState | null {
+  if (!text) return null;
+  let v: Record<string, unknown>;
+  try {
+    v = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!v || typeof v !== "object" || v.format !== FORMAT) return null;
+  const { x, y, width, height, maximized } = v;
+  if (
+    !finite(x, -LIMIT) ||
+    !finite(y, -LIMIT) ||
+    !finite(width, 1) ||
+    !finite(height, 1) ||
+    typeof maximized !== "boolean"
+  )
+    return null;
+  return { x, y, width, height, maximized };
+}
+
+export function serialize(state: SavedWindowState): string {
+  const { x, y, width, height, maximized } = state;
+  return `${JSON.stringify({ format: FORMAT, x, y, width, height, maximized })}\n`;
+}
+
+/**
+ * The state to save after `snap`. Only a normal window says where it is; a maximized one only
+ * flips the flag, so un-maximizing after a restart returns to the last normal bounds (Tauri
+ * window-state keeps prev_x/prev_y for the same reason). Minimized, hidden or full-screen
+ * windows change nothing.
+ */
+export function nextState(prev: SavedWindowState | null, snap: WindowSnapshot): SavedWindowState | null {
+  if (snap.minimized || !snap.visible || snap.fullscreen) return prev;
+  if (!(snap.width >= 1 && snap.height >= 1)) return prev;
+  if (snap.maximized) {
+    
+    return prev
+      ? { ...prev, maximized: true }
+      : { x: snap.x, y: snap.y, width: snap.width, height: snap.height, maximized: true };
+  }
+  return { x: snap.x, y: snap.y, width: snap.width, height: snap.height, maximized: false };
+}
+
+const same = (a: SavedWindowState | null, b: SavedWindowState | null) =>
+  a === b ||
+  (!!a &&
+    !!b &&
+    a.x === b.x &&
+    a.y === b.y &&
+    a.width === b.width &&
+    a.height === b.height &&
+    a.maximized === b.maximized);
+
+export interface Tracker {
+  readonly saved: SavedWindowState | null;
+  /** A move or resize happened: capture once things settle. */
+  changed(): void;
+  /** Captures now (and waits for a capture in flight). */
+  flush(): Promise<SavedWindowState | null>;
+  /** Forgets the saved state; the next capture starts over. */
+  clear(): void;
+  stop(): void;
+}
+
+export function createTracker(options: {
+  initial: SavedWindowState | null;
+  read(): Promise<WindowSnapshot>;
+  write(state: SavedWindowState): void;
+  /** Debounce for move/resize bursts, ms. Also lets the maximize animation finish. */
+  delay?: number;
+}): Tracker {
+  const delay = options.delay ?? 400;
+  let saved = options.initial;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let chain: Promise<SavedWindowState | null> = Promise.resolve(saved);
+
+  const capture = async (): Promise<SavedWindowState | null> => {
+    let snap: WindowSnapshot;
+    try {
+      snap = await options.read();
+    } catch {
+      return saved; 
+    }
+    const next = nextState(saved, snap);
+    if (next && !same(next, saved)) {
+      saved = next;
+      try {
+        options.write(next);
+      } catch (error) {
+        console.error("[akan-native] window-state: saving failed", error);
+      }
+    }
+    return saved;
+  };
+  const enqueue = () => (chain = chain.then(capture, capture));
+  const cancel = () => {
+    if (timer !== undefined) clearTimeout(timer);
+    timer = undefined;
+  };
+
+  return {
+    get saved() {
+      return saved;
+    },
+    changed() {
+      cancel();
+      timer = setTimeout(() => {
+        timer = undefined;
+        void enqueue();
+      }, delay);
+    },
+    flush() {
+      cancel();
+      return enqueue();
+    },
+    clear() {
+      cancel();
+      saved = null;
+    },
+    stop: cancel,
+  };
+}

package/webkit/bootCsr.tsx

@@ -45,12 +45,19 @@ export const bootCsr = async (context: Record<string, CsrRouteModuleEntry>) => {
   const i18n = parseAkanI18nEnv();
   window.document.body.style.overflow = "hidden";
   initializeMobileTargetFromSearch();
-  const mobileBasePath = window.__AKAN_MOBILE_TARGET__?.basePath?.replace(/^\/+|\/+$/g, "");
-  const pathname = mobileBasePath && window.location.pathname === "/" ? `/${mobileBasePath}` : window.location.pathname;
-  if (pathname === "/404") return;
+  if (window.location.pathname === "/404") return;
 
   const [device, jwt] = await Promise.all([Device.load({ supportLanguages: i18n.locales }), getStoredAuthToken()]);
-  if (!window.__AKAN_MOBILE_TARGET__ && !pathname.startsWith(`/${device.lang}`))
+  const mobileTarget = window.__AKAN_MOBILE_TARGET__;
+  
+  if (mobileTarget && window.location.pathname === "/")
+    window.history.replaceState(
+      window.history.state,
+      "",
+      `${mobileHomePath(device.lang, mobileTarget)}${window.location.search}${window.location.hash}`,
+    );
+  const pathname = window.location.pathname;
+  if (!mobileTarget && !pathname.startsWith(`/${device.lang}`))
     window.location.replace(`/${device.lang}${pathname}${window.location.search}${window.location.hash}`);
 
   if (jwt) initAuth({ jwt });
@@ -148,7 +155,7 @@ export const bootCsr = async (context: Record<string, CsrRouteModuleEntry>) => {
     parentLayouts: RouteRender[] = [],
     parentPaths: string[] = [],
     parentPageConfigChain: PageConfig[] = [],
-    parentOverrides: RouteRender[] = [],
+    parentRootRenders: RouteRender[] = [],
   ): PathRoute[] => {
     const parentPath = parentPaths.filter((path) => path !== "/").join("");
     const isRouteGroup = /^\/\(.*\)$/.test(route.path);
@@ -161,19 +168,17 @@ export const bootCsr = async (context: Record<string, CsrRouteModuleEntry>) => {
     const currentLayoutConfig = route.renderLayout && route.layoutPageConfig ? route.layoutPageConfig : null;
     
     const currentOverrideRenders = route.renderOverrides ? [route.renderOverrides] : [];
-    const overrideRenders = [...parentOverrides, ...currentOverrideRenders];
+    const nodeRenders = [...currentOverrideRenders, ...(route.renderLayout ? [route.renderLayout] : [])];
     const rootLayoutStack = [...parentRootLayouts, ...(currentRootLayout ? [currentRootLayout] : [])];
-    const renderRootLayouts = [...overrideRenders, ...rootLayoutStack];
-    const renderLayouts = [...parentLayouts, ...(currentLayout ? [currentLayout] : [])];
+    const renderRootLayouts = isRoot ? [...parentRootRenders, ...nodeRenders] : parentRootRenders;
+    const renderLayouts = isRoot ? parentLayouts : [...parentLayouts, ...nodeRenders];
     const pageConfigChain = [
       ...parentPageConfigChain,
       ...(currentRootLayout || currentLayout ? (currentLayoutConfig ? [currentLayoutConfig] : []) : []),
     ];
-    const pageRenderRootLayouts =
-      route.pageIncludesOwnLayout === false && currentRootLayout
-        ? [...overrideRenders, ...parentRootLayouts]
-        : renderRootLayouts;
-    const pageRenderLayouts = route.pageIncludesOwnLayout === false && currentLayout ? parentLayouts : renderLayouts;
+    const pageNodeRenders = route.pageIncludesOwnLayout === false ? currentOverrideRenders : nodeRenders;
+    const pageRenderRootLayouts = isRoot ? [...parentRootRenders, ...pageNodeRenders] : parentRootRenders;
+    const pageRenderLayouts = isRoot ? parentLayouts : [...parentLayouts, ...pageNodeRenders];
     const pageRenderConfigChain =
       route.pageIncludesOwnLayout === false && (currentRootLayout || currentLayout)
         ? parentPageConfigChain
@@ -206,7 +211,7 @@ export const bootCsr = async (context: Record<string, CsrRouteModuleEntry>) => {
         : []),
       ...(route.children.size
         ? [...route.children.values()].flatMap((child) =>
-            getPathRoutes(child, rootLayoutStack, renderLayouts, pathSegments, pageConfigChain, overrideRenders),
+            getPathRoutes(child, rootLayoutStack, renderLayouts, pathSegments, pageConfigChain, renderRootLayouts),
           )
         : []),
     ];
@@ -264,6 +269,13 @@ function initializeMobileTargetFromSearch() {
   window.__AKAN_MOBILE_TARGET__ = { name, basePath, ...(indexPath ? { indexPath } : {}) };
 }
 
+function mobileHomePath(lang: string, target: { basePath?: string; indexPath?: string }) {
+  const segments = [lang, target.basePath, target.indexPath]
+    .flatMap((part) => (part ?? "").split("/"))
+    .filter((segment) => segment.length > 0);
+  return `/${segments.join("/")}`;
+}
+
 function validateRouteModuleExports(key: string, mod: RouteModule) {
   const parsed = parseRouteModuleKey(key);
   if (parsed.kind === "overrides") {

package/webkit/index.ts

@@ -4,8 +4,6 @@ export { createRobotPage, createSitemapPage } from "./seoPages";
 export type * from "./types";
 export { useBodyScrollLock } from "./useBodyScrollLock";
 export { useCamera } from "./useCamera";
-export { useCodepush } from "./useCodepush";
-export { useContact } from "./useContact";
 export { useCsrValues } from "./useCsrValues";
 export { useDebounce } from "./useDebounce";
 export { useEscapeKey } from "./useEscapeKey";

package/webkit/nativeNavigation.ts

@@ -0,0 +1,116 @@
+"use client";
+import { router as clientRouter, debugFrame, normalizeDeepLinkHref } from "akanjs/client";
+import { app, isNativeApp, push } from "akanjs/client/native";
+
+export interface NativeBackState {
+  path: string;
+  keyboardHeight: number;
+  keyboardVisible: boolean;
+  router: { back: () => void };
+}
+
+interface NativeNavigationOptions {
+  historyIdx: () => number;
+  backState: () => NativeBackState;
+  /** A back press while the keyboard is up only puts it away. */
+  dismissKeyboard: () => unknown;
+}
+
+/** A native shell's deep links, push taps and Android back button, for the CSR frame that owns the history. */
+export class NativeNavigation {
+  #mountedAt = Date.now();
+  #handled: { href: string; handledAt: number } | null = null;
+  #didResetStack = false;
+
+  constructor(readonly options: NativeNavigationOptions) {}
+
+  listen() {
+    if (!isNativeApp()) return () => undefined;
+    
+    if (push.isSupported("setForegroundPresentation"))
+      void push
+        .setForegroundPresentation({ banner: true, list: true, sound: true, badge: true })
+        .catch(() => undefined);
+    const stops = [
+      app.listen("urlOpen", ({ url }) => {
+        this.openDeepLink(url);
+      }),
+      app.listen("backButton", () => {
+        this.back();
+      }),
+      push.listen("action", ({ message }) => {
+        this.openPushLink(message.data.url);
+      }),
+    ];
+    return () => {
+      for (const stop of stops) stop();
+    };
+  }
+
+  openDeepLink(url: string) {
+    const href = normalizeDeepLinkHref(url);
+    const now = Date.now();
+    const lastHandled = this.#handled;
+    const resetStack = !lastHandled && now - this.#mountedAt < 5000;
+    if (lastHandled?.href === href && now - lastHandled.handledAt < 1000) return;
+    this.#handled = { href, handledAt: now };
+    debugFrame("native.deepLink", {
+      href,
+      resetStack,
+      historyIdx: this.options.historyIdx(),
+      mountedForMs: now - this.#mountedAt,
+      routerReady: clientRouter.isInitialized,
+    });
+    if (resetStack) this.#didResetStack = true;
+    this.#enterWhenReady(href, resetStack);
+  }
+
+  openPushLink(url: unknown) {
+    if (typeof url !== "string" || !url.startsWith("/") || url.startsWith("//")) {
+      debugFrame("native.pushLink.skipped", { url: typeof url === "string" ? url : null });
+      return;
+    }
+    this.openDeepLink(url);
+  }
+
+  back() {
+    const backState = this.options.backState();
+    debugFrame("native.backButton", {
+      historyIdx: this.options.historyIdx(),
+      path: backState.path,
+      keyboardHeight: backState.keyboardHeight,
+    });
+    if (backState.keyboardVisible) {
+      void this.options.dismissKeyboard();
+      return;
+    }
+    if (this.options.historyIdx() > 0) {
+      backState.router.back();
+      return;
+    }
+    const fallbackPath = window.__AKAN_MOBILE_TARGET__?.indexPath ?? "/";
+    
+    if (this.#didResetStack || NativeNavigation.#homeRelative(backState.path) === fallbackPath) {
+      void app.exit().catch(() => undefined);
+      return;
+    }
+    clientRouter.backOrFallback(fallbackPath, { scrollToTop: false });
+  }
+
+  static #homeRelative(routePath: string) {
+    const basePath = window.__AKAN_MOBILE_TARGET__?.basePath?.replace(/^\/+|\/+$/g, "");
+    const segments = routePath.split("/").filter(Boolean);
+    if (segments[0] === ":lang") segments.shift();
+    if (basePath && segments[0] === basePath) segments.shift();
+    return `/${segments.join("/")}`;
+  }
+
+  #enterWhenReady(href: string, resetStack: boolean, attempt = 0) {
+    if (!clientRouter.isInitialized) {
+      if (attempt < 40) window.setTimeout(() => this.#enterWhenReady(href, resetStack, attempt + 1), 50);
+      else debugFrame("native.deepLink.skipped", { href, reason: "router-not-ready" });
+      return;
+    }
+    clientRouter.enterDeepLink(href, { resetStack, scrollToTop: true });
+  }
+}

package/webkit/nativePurchase.ts

@@ -0,0 +1,93 @@
+"use client";
+import { app, type IapTransaction, loadIap } from "akanjs/client/native";
+
+export type PurchaseProductType = "consumable" | "nonConsumable" | "subscription";
+
+export interface PurchaseProductInfo {
+  id: string;
+  type: PurchaseProductType;
+}
+
+export interface BillingVerification {
+  platform: "apple" | "google";
+  packageName: string;
+  productId: string;
+  receipt: string;
+  transactionId: string;
+}
+
+export type PurchaseCallback = (transaction: IapTransaction, verified: unknown) => void | Promise<void>;
+
+export interface NativePurchaseOptions {
+  productInfo: PurchaseProductInfo[];
+  /** The verification server's origin; it answers `POST <url>/billing/verifyBilling`. */
+  url: string;
+  onPay?: PurchaseCallback;
+  onSubscribe?: PurchaseCallback;
+}
+
+export type SettleResult = "finished" | "unverified" | "skipped";
+
+/** One transaction's way from the store to the app: verified by the server, handed to the app, then finished. */
+export class NativePurchase {
+
+  static readonly #claimed = new Set<string>();
+
+  constructor(readonly options: NativePurchaseOptions) {}
+
+  typeOf(productId: string): PurchaseProductType {
+    return this.options.productInfo.find(({ id }) => id === productId)?.type ?? "nonConsumable";
+  }
+
+  async verificationOf({ id, productId, verification }: IapTransaction): Promise<BillingVerification | null> {
+    if (verification.jws)
+      return {
+        platform: "apple",
+        packageName: (await app.getInfo()).id,
+        productId,
+        receipt: verification.jws,
+        transactionId: id,
+      };
+    if (verification.purchaseToken)
+      return {
+        platform: "google",
+        packageName: verification.packageName ?? (await app.getInfo()).id,
+        productId,
+        receipt: verification.purchaseToken,
+        transactionId: verification.orderId ?? id,
+      };
+    return null;
+  }
+
+  async verify(transaction: IapTransaction): Promise<{ ok: true; body: unknown } | { ok: false }> {
+    const data = await this.verificationOf(transaction);
+    if (!data) return { ok: false };
+    const res = await fetch(`${this.options.url.replace(/\/$/, "")}/billing/verifyBilling`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ data }),
+    });
+    if (!res.ok) return { ok: false };
+    return { ok: true, body: await res.json().catch(() => null) };
+  }
+
+  async settle(transaction: IapTransaction): Promise<SettleResult> {
+    if (transaction.state !== "purchased" || NativePurchase.#claimed.has(transaction.id)) return "skipped";
+    NativePurchase.#claimed.add(transaction.id);
+    try {
+      const verified = await this.verify(transaction);
+      if (!verified.ok) {
+        NativePurchase.#claimed.delete(transaction.id);
+        return "unverified";
+      }
+      const type = this.typeOf(transaction.productId);
+      await (type === "subscription" ? this.options.onSubscribe : this.options.onPay)?.(transaction, verified.body);
+      const { iap } = await loadIap();
+      await iap.finish({ transactionId: transaction.id, consume: type === "consumable" });
+      return "finished";
+    } catch (error) {
+      NativePurchase.#claimed.delete(transaction.id);
+      throw error;
+    }
+  }
+}

package/webkit/useCamera.tsx

@@ -1,15 +1,21 @@
 "use client";
-import { Device, isMobileDevice, Translator } from "akanjs/client";
-import { type CapacitorPermissionState, loadCapacitorCamera } from "akanjs/client/capacitor";
+import { Translator } from "akanjs/client";
+import {
+  AkanNativeError,
+  dialog,
+  fileBlob,
+  isNativeApp,
+  loadCamera,
+  opener,
+  type Photo,
+  releaseFile,
+} from "akanjs/client/native";
 import { parseAkanI18nEnv } from "akanjs/common";
 import { useEffect, useState } from "react";
 
-type PermissionStatus = {
-  camera: CapacitorPermissionState;
-  photos: CapacitorPermissionState;
-};
+type PermissionState = "granted" | "denied" | "prompt";
 
-/** The four strings the native picker shows. Omitted ones come from the `base` dictionary. */
+/** The four strings the camera-or-library sheet shows. Omitted ones come from the `base` dictionary. */
 export interface CameraPromptLabels {
   header?: string;
   photo?: string;
@@ -20,82 +26,81 @@ export interface CameraPromptLabels {
 const promptLabel = (key: string, override?: string) =>
   override ?? Translator.translateByLocale(Translator.getActiveLocale() ?? parseAkanI18nEnv().defaultLocale, key);
 
-/** `checkPermission` opens the app settings when camera or photo access is denied. */
+const toBase64 = (bytes: Uint8Array) => {
+  let binary = "";
+  for (let at = 0; at < bytes.length; at += 0x8000) binary += String.fromCharCode(...bytes.subarray(at, at + 0x8000));
+  return btoa(binary);
+};
+
+const toDataUrl = async (photo: Photo) => {
+  try {
+    const bytes = new Uint8Array(await (await fileBlob(photo)).arrayBuffer());
+    return { dataUrl: `data:${photo.mime};base64,${toBase64(bytes)}` };
+  } finally {
+    void releaseFile(photo).catch(() => undefined);
+  }
+};
+
+/** Photos arrive as upright JPEG data URLs; a denied camera opens the app settings instead of resolving. */
 export const useCamera = ({ promptLabels = {} }: { promptLabels?: CameraPromptLabels } = {}) => {
-  const [permissions, setPermissions] = useState<PermissionStatus>({ camera: "prompt", photos: "prompt" });
+  const [permissions, setPermissions] = useState<{ camera: PermissionState }>({ camera: "prompt" });
 
-  const checkPermission = async (type: "photos" | "camera" | "all") => {
-    try {
-      const { Camera } = await loadCapacitorCamera();
-      if (type !== "all") {
-        if (permissions[type] === "prompt") {
-          const { [type]: state } = await Camera.requestPermissions();
-          setPermissions((prev) => ({ ...prev, [type]: state }));
-        } else if (permissions[type] === "denied") {
-          location.assign("app-settings:");
-          return;
-        }
-      } else {
-        if (permissions.camera === "prompt" || permissions.photos === "prompt") {
-          const permissions = await Camera.requestPermissions();
-          setPermissions(permissions);
-        } else if (permissions.camera === "denied" || permissions.photos === "denied") {
-          location.assign("app-settings:");
-          return;
-        }
-      }
-    } catch {
-    }
+  const openSettingsWhenDenied = async (error: unknown) => {
+    const code = AkanNativeError.from(error).code;
+    if (code === "CANCELLED") return;
+    if (code !== "PERMISSION_DENIED") throw error;
+    setPermissions({ camera: "denied" });
+    await opener.openSettings();
+  };
+
+  const checkPermission = async () => {
+    if (!isNativeApp()) return permissions.camera;
+    const { camera } = await loadCamera();
+    const { camera: state } = await camera.requestPermission();
+    setPermissions({ camera: state });
+    if (state === "denied") await opener.openSettings();
+    return state;
+  };
+
+  const chooseSource = async (): Promise<"camera" | "library" | null> => {
+    const { index } = await dialog.actionSheet({
+      title: promptLabel("base.cameraPromptHeader", promptLabels.header),
+      options: [
+        { title: promptLabel("base.cameraPromptPhoto", promptLabels.photo) },
+        { title: promptLabel("base.cameraPromptPicture", promptLabels.picture) },
+        { title: promptLabel("base.cameraPromptCancel", promptLabels.cancel), style: "cancel" },
+      ],
+    });
+    return index === 0 ? "library" : index === 1 ? "camera" : null;
   };
 
   const getPhoto = async (src: "prompt" | "camera" | "photos" = "prompt") => {
-    const { Camera, CameraResultType, CameraSource } = await loadCapacitorCamera();
-    const source =
-      Device.getDevice().info.platform !== "web"
-        ? src === "prompt"
-          ? CameraSource.Prompt
-          : src === "camera"
-            ? CameraSource.Camera
-            : CameraSource.Photos
-        : CameraSource.Photos;
-    const permission = src === "prompt" ? "all" : src === "camera" ? "camera" : "photos";
-    await checkPermission(permission);
+    const source = !isNativeApp() || src === "photos" ? "library" : src === "camera" ? "camera" : await chooseSource();
+    if (!source) return;
+    const { camera } = await loadCamera();
     try {
-      const photo = await Camera.getPhoto({
-        quality: 100,
-        source,
-        allowEditing: false,
-        resultType: CameraResultType.DataUrl,
-        promptLabelHeader: promptLabel("base.cameraPromptHeader", promptLabels.header),
-        promptLabelPhoto: promptLabel("base.cameraPromptPhoto", promptLabels.photo),
-        promptLabelPicture: promptLabel("base.cameraPromptPicture", promptLabels.picture),
-        promptLabelCancel: promptLabel("base.cameraPromptCancel", promptLabels.cancel),
-      });
-      return photo;
-    } catch (e) {
-      if (e === "User cancelled photos app") return;
+      return await toDataUrl(await camera.takePhoto({ source }));
+    } catch (error) {
+      await openSettingsWhenDenied(error);
     }
   };
 
-  const pickImage = async () => {
-    await checkPermission("photos");
-    const { Camera } = await loadCapacitorCamera();
-    const photo = await Camera.pickImages({
-      quality: 90,
-    });
-
-    return photo;
+  const pickImage = async ({ limit }: { limit?: number } = {}) => {
+    const { camera } = await loadCamera();
+    try {
+      const { photos } = await camera.pickImages(limit ? { limit } : {});
+      return await Promise.all(photos.map(toDataUrl));
+    } catch (error) {
+      await openSettingsWhenDenied(error);
+    }
   };
 
   useEffect(() => {
-    void (async () => {
-      if (!isMobileDevice()) return;
-      try {
-        const { Camera } = await loadCapacitorCamera();
-        setPermissions(await Camera.checkPermissions());
-      } catch {
-      }
-    })();
+    if (!isNativeApp()) return;
+    void loadCamera()
+      .then(({ camera }) => camera.checkPermission())
+      .then(({ camera: state }) => setPermissions({ camera: state }))
+      .catch(() => undefined);
   }, []);
   return { permissions, getPhoto, pickImage, checkPermission };
 };