akanjs 2.2.4-rc.4 → 2.2.4

package/ui/System/Reconnect.tsx

@@ -1,7 +1,7 @@
 "use client";
 import { clsx, fetch, usePage } from "akanjs/client";
 import { useInterval } from "akanjs/webkit";
-
+// import { client } from "akanjs/signal";
 import { useCallback, useEffect, useRef, useState } from "react";
 import { TbPlugConnected, TbPlugConnectedX } from "react-icons/tb";
 
@@ -22,7 +22,7 @@ export const Reconnect = () => {
   }, []);
 
   const handleDisconnect = async () => {
-    
+    // 페이지가 백그라운드 상태에서 disconnect가 발생하면 무시
     if (document.hidden) {
       wasHiddenOnDisconnect.current = true;
       return;
@@ -39,14 +39,14 @@ export const Reconnect = () => {
   };
 
   const handleVisibilityChange = useCallback(() => {
-    
+    // 페이지가 다시 보이게 될 때
     if (!document.hidden && wasHiddenOnDisconnect.current) {
-      
+      // socket이 연결되어 있으면 문제없음
       if (fetch.ws.connected) {
         wasHiddenOnDisconnect.current = false;
         setConnectStatus("normal");
       } else {
-        
+        // socket이 끊어져 있으면 실제 서버 문제인지 확인
         void handleDisconnect();
       }
     }
@@ -56,6 +56,7 @@ export const Reconnect = () => {
     fetch.ws.on("connect", handleConnect);
     fetch.ws.on("disconnect", () => handleDisconnect());
 
+    // Page Visibility API 이벤트 리스너 추가
     document.addEventListener("visibilitychange", handleVisibilityChange);
 
     setTimeout(() => {

package/ui/System/Root.tsx

@@ -1,6 +1,7 @@
 "use client";
 import type { ReactNode } from "react";
 
+// TODO: may be deprecated?
 export interface RootProps {
   children: ReactNode;
   st: unknown;

package/ui/System/SSR.tsx

@@ -35,10 +35,16 @@ const SSRProvider = ({
 }: SSRProviderProps) => {
   setRequestTheme(theme);
 
+  // Resolve the active locale exactly like `l()` does (getPageInfo / request), not via `params.lang`,
+  // which is only populated when the matched route pattern contains `:lang` and can otherwise diverge.
   const { lang: activeLocale } = usePage();
 
+  // Server (RSC worker) renders server components: seed every locale into the shared Translator. This is
+  // free on the server (it never reaches the browser bundle) and makes server-component translations
+  // resolve no matter how the locale is routed.
   if (allDictionary) for (const [lng, dict] of Object.entries(allDictionary)) Translator.seed(lng, dict);
 
+  // Only the active locale is serialized to the client (Flight payload) to keep the browser bundle lean.
   const activeDictionary = allDictionary?.[activeLocale] ?? dictionary;
 
   return (
@@ -87,7 +93,7 @@ const ServerFontFace = ({ fonts }: { fonts: ReactFont[] }) => {
         <link key={preload.href} rel="preload" href={preload.href} as="font" type={preload.type} crossOrigin="" />
       ))}
       {css ? (
-        
+        // biome-ignore lint/security/noDangerouslySetInnerHtml: injecting @font-face CSS
         <style data-akan-fonts dangerouslySetInnerHTML={{ __html: css }} />
       ) : null}
     </>

package/ui/ToggleSelect.tsx

@@ -22,7 +22,8 @@ export const ToggleSelect = <I extends string | number | boolean | null>({
 }: ToggleSelectProps<I>) => {
   const { l } = usePage();
   const validateResult = value !== null ? validate(value) : false;
-
+  // const status: "error" | "warning" | "success" =
+  //   !nullable && !value?.length ? "warning" : validateResult === true ? "success" : "error";
   const invalidMessage =
     value === null || (typeof value === "string" && !value.length) || validateResult === true
       ? null
@@ -54,7 +55,10 @@ export const ToggleSelect = <I extends string | number | boolean | null>({
             className={clsx(
               "btn btn-sm",
               { "bg-success/70 text-success-content": isSelected, "btn-disabled cursor-not-allowed": isDisabled },
-
+              // {
+              //   "btn-error": status === "error",
+              //   "btn-warning": status === "warning",
+              // },
               btnClassName,
             )}
             onClick={() => {
@@ -85,7 +89,8 @@ interface MultiProps {
 const Multi = ({ className, btnClassName, items, nullable, validate, value, onChange, disabled }: MultiProps) => {
   const { l } = usePage();
   const validateResult = validate(value);
-
+  // const status: "error" | "warning" | "success" =
+  //   !nullable && !value.length ? "warning" : validateResult === true ? "success" : "error";
   const invalidMessage =
     !value.length || validateResult === true
       ? null

package/ui/Unauthorized.tsx

@@ -1,4 +1,4 @@
-
+// "use client";
 import { clsx, usePage } from "akanjs/client";
 import type { ReactNode } from "react";
 import { AiOutlineBlock } from "react-icons/ai";

package/webkit/bootCsr.test.tsx

@@ -0,0 +1,153 @@
+import { afterEach, beforeAll, describe, expect, mock, test } from "bun:test";
+
+const originalWindow = globalThis.window;
+const originalDocument = globalThis.document;
+const originalEnv = { ...process.env };
+
+const deviceState = {
+  lang: "en",
+  platform: "web",
+};
+const storageState = {
+  jwt: null as string | null,
+};
+
+beforeAll(() => {
+  mock.module("akanjs/client", () => ({
+    DEFAULT_BOTTOM_INSET: 34,
+    DEFAULT_TOP_INSET: 44,
+    csrContext: { Provider: ({ children }: { children: unknown }) => children },
+    defaultPageState: {
+      transition: "none",
+      topSafeArea: 0,
+      bottomSafeArea: 0,
+      topInset: 0,
+      bottomInset: 0,
+      gesture: true,
+      cache: false,
+    },
+    router: {
+      state: {},
+      set: () => undefined,
+      emit: () => undefined,
+      on: () => undefined,
+      off: () => undefined,
+    },
+    Device: {
+      load: async () => ({
+        lang: deviceState.lang,
+        info: { platform: deviceState.platform },
+        topSafeArea: 11,
+        bottomSafeArea: 22,
+      }),
+      getDevice: () => ({
+        info: { platform: deviceState.platform },
+      }),
+    },
+    initAuth: () => undefined,
+    storage: {
+      getItem: async (key: string) => (key === "jwt" ? storageState.jwt : null),
+    },
+  }));
+  mock.module("react-dom/client", () => ({
+    createRoot: () => ({ render: () => undefined }),
+  }));
+  mock.module("@capacitor/app", () => ({
+    App: {
+      addListener: () => ({ remove: () => undefined }),
+    },
+  }));
+  mock.module("@react-spring/web", () => ({
+    useSpringValue: () => ({ to: () => 0, start: async () => undefined }),
+  }));
+  mock.module("@use-gesture/react", () => ({
+    useDrag: () => () => ({}),
+  }));
+});
+
+const installWindow = ({
+  href,
+  replace,
+  root = true,
+}: {
+  href: string;
+  replace?: (href: string) => void;
+  root?: boolean;
+}) => {
+  const url = new URL(href);
+  const body = { style: {} } as HTMLBodyElement;
+  const document = {
+    body,
+    getElementById: (id: string) => (root && id === "root" ? ({ nodeType: 1 } as HTMLElement) : null),
+  } as unknown as Document;
+  const window = {
+    document,
+    location: {
+      href,
+      origin: url.origin,
+      pathname: url.pathname,
+      search: url.search,
+      hash: url.hash,
+      replace: replace ?? (() => undefined),
+    },
+  } as unknown as Window & typeof globalThis;
+  Object.defineProperty(globalThis, "window", { value: window, configurable: true });
+  Object.defineProperty(globalThis, "document", { value: document, configurable: true });
+  Object.defineProperty(globalThis, "location", { value: window.location, configurable: true });
+};
+
+afterEach(() => {
+  Object.defineProperty(globalThis, "window", { value: originalWindow, configurable: true });
+  Object.defineProperty(globalThis, "document", { value: originalDocument, configurable: true });
+  Object.defineProperty(globalThis, "location", { value: originalWindow?.location, configurable: true });
+  process.env = { ...originalEnv };
+  deviceState.lang = "en";
+  deviceState.platform = "web";
+  storageState.jwt = null;
+});
+
+describe("bootCsr", () => {
+  test("exits early on 404 before route loading", async () => {
+    installWindow({ href: "https://example.test/404" });
+    let loaded = false;
+    const { bootCsr } = await import("./bootCsr");
+
+    await bootCsr({
+      "./_index.tsx": async () => {
+        loaded = true;
+        return { default: () => null };
+      },
+    });
+
+    expect(loaded).toBe(false);
+    expect(document.body.style.overflow).toBe("hidden");
+  });
+
+  test("redirects to language-prefixed path when missing language prefix", async () => {
+    const replacements: string[] = [];
+    installWindow({ href: "https://example.test/home?a=1#top", replace: (href) => replacements.push(href) });
+    const { bootCsr } = await import("./bootCsr");
+
+    await bootCsr({
+      "./_index.tsx": async () => ({ default: () => null }),
+    });
+
+    expect(replacements).toEqual(["/en/home?a=1#top"]);
+  });
+
+  test("initializes mobile target from local Capacitor CSR URL", async () => {
+    const replacements: string[] = [];
+    installWindow({
+      href: "https://example.test/en/?csr=true&akanMobileTarget=default&akanMobileBasePath=minimal",
+      replace: (href) => replacements.push(href),
+    });
+    const { bootCsr } = await import("./bootCsr");
+
+    await bootCsr({
+      "./_index.tsx": async () => ({ default: () => null }),
+    });
+
+    expect(window.__AKAN_MOBILE_TARGET__).toEqual({ name: "default", basePath: "minimal" });
+    expect(replacements).toEqual([]);
+  });
+});

package/webkit/bootCsr.tsx

@@ -24,7 +24,7 @@ import {
   parseRouteModuleKey,
   routeSegmentToTreePath,
 } from "akanjs/common";
-import { createElement, memo, type ReactNode, useRef } from "react"; 
+import { createElement, memo, type ReactNode, useRef } from "react"; // import React 꼭 필요함. 안그러면 csr에서 에러남
 import * as ReactDOM from "react-dom/client";
 import { useCsrValues } from "./useCsrValues";
 import { useFetch } from "./useFetch";
@@ -85,6 +85,7 @@ export const bootCsr = async (context: Record<string, CsrRouteModuleEntry>) => {
   const pathname = mobileBasePath && window.location.pathname === "/" ? `/${mobileBasePath}` : window.location.pathname;
   if (pathname === "/404") return;
 
+  // 1. Collect Device Information
   const [device, jwt] = await Promise.all([Device.load({ supportLanguages: i18n.locales }), storage.getItem("jwt")]);
   if (!window.__AKAN_MOBILE_TARGET__ && !pathname.startsWith(`/${device.lang}`))
     window.location.replace(`/${device.lang}${pathname}${window.location.search}${window.location.hash}`);
@@ -92,6 +93,7 @@ export const bootCsr = async (context: Record<string, CsrRouteModuleEntry>) => {
   if (jwt) initAuth({ jwt });
   Logger.verbose(`Set default language: ${device.lang}`);
 
+  // 2. Create Route Map
   const basePaths = process.env.AKAN_PUBLIC_BASE_PATHS ? parseBasePaths(process.env.AKAN_PUBLIC_BASE_PATHS) : null;
   const currentBasePath = basePaths ? pathname.split("/")[2] : undefined;
   if (currentBasePath && basePaths && !basePaths.includes(currentBasePath))
@@ -106,7 +108,7 @@ export const bootCsr = async (context: Record<string, CsrRouteModuleEntry>) => {
       const parsed = parseRouteModuleKey(key);
       if (basePaths) {
         const pageBasePath = parsed.sourceRouteSegments.find((segment) => !/^\(.+\)$/.test(segment));
-        if (pageBasePath && otherBasePaths.includes(pageBasePath)) return; 
+        if (pageBasePath && otherBasePaths.includes(pageBasePath)) return; // ignore other base paths
       }
       const entry = typeof value === "function" ? { loader: value } : value;
       const pageContent = await entry.loader();
@@ -173,7 +175,8 @@ export const bootCsr = async (context: Record<string, CsrRouteModuleEntry>) => {
       resolveError: layoutPage ? () => layoutPage.Error : undefined,
     };
     targetRouteMap.set(targetPath, {
-
+      // action: pages[path]?.action,
+      // ErrorBoundary: pages[path]?.ErrorBoundary,
       ...(targetRouteMap.get(targetPath) ?? { path: targetPath, children: new Map<string, Route>() }),
       ...(parsed.kind === "layout"
         ? { renderLayout: routeRender }

package/webkit/lazy.tsx

@@ -1,5 +1,12 @@
 import type { ComponentType, ReactNode } from "react";
-
+// `useState` / `useEffect` are NOT exported from `react.react-server.js`
+// (the build Bun resolves `react` to under `--conditions react-server`).
+// Named-importing them here would crash RSC worker evaluation with
+// "Export named 'useEffect' not found". They're only ever called on the
+// browser anyway (the `ssr: false` gate below is the only path that calls
+// them, and it short-circuits on the server), so we dereference them
+// through a namespace import — the namespace itself is always importable,
+// and the lookup only happens when the gated Wrapper actually renders.
 import * as React from "react";
 import { forwardRef, lazy as reactLazy } from "react";
 

package/webkit/native.test.tsx

@@ -0,0 +1,341 @@
+import { afterEach, beforeAll, describe, expect, mock, test } from "bun:test";
+
+type RenderHookResult<T> = {
+  get current(): T;
+  unmount: () => void;
+};
+
+type Permission = "prompt" | "granted" | "denied";
+
+const originalWindow = globalThis.window;
+const originalDocument = globalThis.document;
+const effectCleanups: Array<() => void> = [];
+let hookIndex = 0;
+const hookStates: unknown[] = [];
+let hookMemoStates: Array<{ deps: unknown[]; value: unknown }> = [];
+
+const sameDeps = (a: unknown[] | undefined, b: unknown[] | undefined) =>
+  !!a && !!b && a.length === b.length && a.every((value, index) => Object.is(value, b[index]));
+
+const cameraState = {
+  permissions: { camera: "prompt" as Permission, photos: "prompt" as Permission },
+  requested: 0,
+  photoSource: "",
+  cancelled: false,
+};
+const contactsState = {
+  platform: "web",
+  permissions: { contacts: "prompt" as Permission },
+  checked: 0,
+  requested: 0,
+};
+const geolocationState = {
+  permissions: { location: "granted", coarseLocation: "granted" },
+};
+const pushState = {
+  platform: "web",
+  receive: "granted" as "granted" | "denied",
+  registered: 0,
+  autoInit: 0,
+};
+const assigned: string[] = [];
+
+beforeAll(() => {
+  mock.module("react", () => ({
+    Fragment: ({ children }: { children: unknown }) => children,
+    useCallback: <T,>(fn: T, deps?: unknown[]) => {
+      const index = hookIndex++;
+      const memo = hookMemoStates[index];
+      if (memo && sameDeps(memo.deps, deps)) return memo.value as T;
+      hookMemoStates[index] = { deps: deps ?? [], value: fn };
+      return fn;
+    },
+    useMemo: <T,>(factory: () => T, deps?: unknown[]) => {
+      const index = hookIndex++;
+      const memo = hookMemoStates[index];
+      if (memo && sameDeps(memo.deps, deps)) return memo.value as T;
+      const value = factory();
+      hookMemoStates[index] = { deps: deps ?? [], value };
+      return value;
+    },
+    useRef: <T,>(initial: T) => {
+      const index = hookIndex++;
+      if (!hookStates[index]) hookStates[index] = { current: initial };
+      return hookStates[index] as { current: T };
+    },
+    useState: <T,>(initial: T) => {
+      const index = hookIndex++;
+      if (hookStates[index] === undefined)
+        hookStates[index] = typeof initial === "function" ? (initial as () => T)() : initial;
+      const setState = (next: T | ((prev: T) => T)) => {
+        const state = hookStates[index] as T;
+        const nextState = typeof next === "function" ? (next as (prev: T) => T)(state) : next;
+        if (typeof state === "object" && state && typeof nextState === "object" && nextState) {
+          Object.assign(state, nextState);
+        } else {
+          hookStates[index] = nextState;
+        }
+      };
+      return [hookStates[index] as T, setState] as const;
+    },
+    useEffect: (fn: () => (() => undefined) | undefined) => {
+      const cleanup = fn();
+      if (cleanup) effectCleanups.push(cleanup);
+    },
+    forwardRef: (fn: unknown) => fn,
+    lazy: (loader: unknown) => ({ loader }),
+    memo: <T,>(component: T) => component,
+    act: async (fn: () => void | Promise<void>) => await fn(),
+  }));
+  mock.module("akanjs/client", () => ({
+    DEFAULT_BOTTOM_INSET: 34,
+    DEFAULT_TOP_INSET: 44,
+    csrContext: { Provider: ({ children }: { children: unknown }) => children },
+    defaultPageState: {
+      transition: "none",
+      topSafeArea: 0,
+      bottomSafeArea: 0,
+      topInset: 0,
+      bottomInset: 0,
+      gesture: true,
+      cache: false,
+    },
+    Device: {
+      load: async () => ({
+        lang: "en",
+        info: { platform: contactsState.platform },
+        topSafeArea: 11,
+        bottomSafeArea: 22,
+      }),
+      getDevice: () => ({
+        info: { platform: contactsState.platform },
+      }),
+    },
+    initAuth: () => undefined,
+    router: {
+      state: {},
+      set: () => undefined,
+      emit: () => undefined,
+      on: () => undefined,
+      off: () => undefined,
+    },
+    storage: {
+      getItem: async () => null,
+    },
+    isMobileDevice: () => true,
+  }));
+});
+
+const installCapacitorBridge = () => {
+  Object.defineProperty(globalThis, "Capacitor", {
+    value: {
+      Plugins: {
+        Camera: {
+          checkPermissions: async () => cameraState.permissions,
+          requestPermissions: async () => {
+            cameraState.requested += 1;
+            return cameraState.permissions;
+          },
+          getPhoto: async (options: { source: string }) => {
+            cameraState.photoSource = options.source;
+            if (cameraState.cancelled) throw "User cancelled photos app";
+            return { dataUrl: "data:image/png;base64,test" };
+          },
+          pickImages: async () => ({ photos: [{ webPath: "image.png" }] }),
+        },
+        Contacts: {
+          checkPermissions: async () => {
+            contactsState.checked += 1;
+            return contactsState.permissions;
+          },
+          requestPermissions: async () => {
+            contactsState.requested += 1;
+            return contactsState.permissions;
+          },
+          getContacts: async () => ({ contacts: [{ name: { display: "Ada" }, phones: [{ number: "123" }] }] }),
+        },
+        Geolocation: {
+          requestPermissions: async () => geolocationState.permissions,
+          getCurrentPosition: async () => ({ coords: { latitude: 37, longitude: 127 } }),
+        },
+        Device: {
+          getInfo: async () => ({ platform: pushState.platform }),
+        },
+        PushNotifications: {
+          requestPermissions: async () => ({ receive: pushState.receive }),
+          checkPermissions: async () => ({ receive: pushState.receive }),
+          register: async () => {
+            pushState.registered += 1;
+          },
+        },
+        FCM: {
+          setAutoInit: async () => {
+            pushState.autoInit += 1;
+          },
+          getToken: async () => ({ token: "token-1" }),
+        },
+      },
+    },
+    configurable: true,
+  });
+};
+
+const installWindow = () => {
+  const createElement = (tagName = "div") =>
+    ({
+      nodeType: 1,
+      nodeName: tagName.toUpperCase(),
+      tagName: tagName.toUpperCase(),
+      namespaceURI: "http://www.w3.org/1999/xhtml",
+      ownerDocument: null,
+      style: {},
+      childNodes: [],
+      addEventListener: () => undefined,
+      removeEventListener: () => undefined,
+      appendChild: () => undefined,
+      removeChild: () => undefined,
+      insertBefore: () => undefined,
+      setAttribute: () => undefined,
+      removeAttribute: () => undefined,
+    }) as unknown as HTMLDivElement;
+  const document = {
+    nodeType: 9,
+    documentElement: createElement("html"),
+    defaultView: null,
+    createElement,
+    addEventListener: () => undefined,
+    removeEventListener: () => undefined,
+  } as unknown as Document;
+  (document.documentElement as unknown as { ownerDocument: Document }).ownerDocument = document;
+  const window = {
+    location: { assign: (href: string) => assigned.push(href) },
+    document,
+    Capacitor: (globalThis as typeof globalThis & { Capacitor?: unknown }).Capacitor,
+    HTMLIFrameElement: class HTMLIFrameElement {},
+    Node: class Node {},
+    addEventListener: () => undefined,
+    removeEventListener: () => undefined,
+  } as unknown as Window & typeof globalThis;
+  (document as unknown as { defaultView: Window }).defaultView = window;
+  installCapacitorBridge();
+  (window as unknown as { Capacitor: unknown }).Capacitor = (
+    globalThis as typeof globalThis & { Capacitor?: unknown }
+  ).Capacitor;
+  Object.defineProperty(globalThis, "window", { value: window, configurable: true });
+  Object.defineProperty(globalThis, "document", { value: document, configurable: true });
+  Object.defineProperty(globalThis, "location", { value: window.location, configurable: true });
+};
+
+const renderHook = <T,>(hook: () => T): RenderHookResult<T> => {
+  hookIndex = 0;
+  const current = hook();
+  return {
+    get current() {
+      return current;
+    },
+    unmount: () =>
+      effectCleanups.splice(0).forEach((cleanup) => {
+        cleanup();
+      }),
+  };
+};
+
+afterEach(() => {
+  Object.defineProperty(globalThis, "window", { value: originalWindow, configurable: true });
+  Object.defineProperty(globalThis, "document", { value: originalDocument, configurable: true });
+  Object.defineProperty(globalThis, "location", { value: originalWindow?.location, configurable: true });
+  Object.defineProperty(globalThis, "Capacitor", { value: undefined, configurable: true });
+  globalThis.__AKAN_CAPACITOR_IMPORTS__ = undefined;
+  cameraState.permissions = { camera: "prompt", photos: "prompt" };
+  cameraState.requested = 0;
+  cameraState.photoSource = "";
+  cameraState.cancelled = false;
+  contactsState.platform = "web";
+  contactsState.permissions = { contacts: "prompt" };
+  contactsState.checked = 0;
+  contactsState.requested = 0;
+  geolocationState.permissions = { location: "granted", coarseLocation: "granted" };
+  pushState.platform = "web";
+  pushState.receive = "granted";
+  pushState.registered = 0;
+  pushState.autoInit = 0;
+  assigned.length = 0;
+  effectCleanups.splice(0);
+  hookIndex = 0;
+  hookStates.length = 0;
+  hookMemoStates = [];
+});
+
+describe("native hooks", () => {
+  test("useCamera requests permissions, uses web photo source, opens settings, and handles cancellation", async () => {
+    installWindow();
+    const { useCamera } = await import("./useCamera");
+    const hook = renderHook(() => useCamera());
+
+    expect(await hook.current.getPhoto("prompt")).toEqual({ dataUrl: "data:image/png;base64,test" });
+    expect(cameraState.photoSource).toBe("PHOTOS");
+    expect(cameraState.requested).toBe(1);
+
+    cameraState.permissions = { camera: "denied", photos: "denied" };
+    await hook.current.checkPermission("all");
+    await hook.current.checkPermission("all");
+    expect(assigned).toEqual(["app-settings:"]);
+
+    cameraState.cancelled = true;
+    expect(await hook.current.getPhoto("photos")).toBeUndefined();
+    hook.unmount();
+  });
+
+  test("useContact skips web initial check, requests permission, opens settings, and returns contacts", async () => {
+    installWindow();
+    const { useContact } = await import("./useContact");
+    const hook = renderHook(() => useContact());
+
+    expect(contactsState.checked).toBe(0);
+    expect(await hook.current.getContacts()).toEqual([{ name: { display: "Ada" }, phones: [{ number: "123" }] }]);
+    expect(contactsState.requested).toBe(1);
+
+    contactsState.permissions = { contacts: "denied" };
+    await hook.current.checkPermission();
+    await hook.current.checkPermission();
+    expect(assigned).toEqual(["app-settings:"]);
+    hook.unmount();
+  });
+
+  test("useGeoLocation returns permission and current position or opens settings", async () => {
+    installWindow();
+    const { useGeoLocation } = await import("./useGeoLocation");
+    const hook = renderHook(() => useGeoLocation());
+
+    expect(await hook.current.checkPermission()).toEqual({ geolocation: "granted", coarseLocation: "granted" });
+    expect(await hook.current.getPosition()).toEqual({ coords: { latitude: 37, longitude: 127 } });
+    geolocationState.permissions = { location: "denied", coarseLocation: "granted" };
+    expect(await hook.current.getPosition()).toBeUndefined();
+    expect(assigned).toEqual(["app-settings:"]);
+    hook.unmount();
+  });
+
+  test("usePushNoti is web no-op, registers native device, opens settings, and reads token", async () => {
+    installWindow();
+    const { usePushNoti } = await import("./usePushNoti");
+    const hook = renderHook(() => usePushNoti());
+
+    await hook.current.init();
+    await hook.current.register();
+    expect(await hook.current.getToken()).toBeUndefined();
+    expect(pushState.registered).toBe(0);
+
+    pushState.platform = "ios";
+    await hook.current.init();
+    await Promise.resolve();
+    await hook.current.register();
+    expect(pushState.autoInit).toBe(1);
+    expect(pushState.registered).toBe(2);
+    expect(await hook.current.getToken()).toBe("token-1");
+
+    pushState.receive = "denied";
+    await hook.current.register();
+    expect(assigned).toEqual(["app-settings:"]);
+    hook.unmount();
+  });
+});

package/webkit/useCamera.tsx

@@ -48,6 +48,7 @@ export const useCamera = () => {
         }
       }
     } catch {
+      //
     }
   };