akanjs 2.2.4 → 2.2.5

package/client/client.decorators.test.ts

@@ -1,74 +0,0 @@
-import { afterEach, beforeAll, describe, expect, mock, test } from "bun:test";
-
-const messageCalls: unknown[] = [];
-const logCalls: unknown[] = [];
-
-beforeAll(() => {
-  mock.module("./useClient", () => ({
-    msg: {
-      loading: (...args: unknown[]) => messageCalls.push(["loading", ...args]),
-      success: (...args: unknown[]) => messageCalls.push(["success", ...args]),
-      error: (...args: unknown[]) => messageCalls.push(["error", ...args]),
-    },
-  }));
-  mock.module("akanjs/common", () => ({
-    Logger: {
-      log: () => undefined,
-      verbose: () => undefined,
-      error: (...args: unknown[]) => logCalls.push(args),
-    },
-    parseAkanI18nEnv: () => ({ locales: ["en", "ko"], defaultLocale: "en" }),
-    parseBasePaths: (value?: string) => (value ? value.split(",").filter(Boolean) : []),
-    getBasePathFromPathname: () => null,
-    pathGet: (path: string, obj: Record<string, unknown>, separator = ".", fallback?: unknown) =>
-      path.split(separator).reduce<unknown>((acc, key) => {
-        if (!acc || typeof acc !== "object") return fallback;
-        return (acc as Record<string, unknown>)[key] ?? fallback;
-      }, obj),
-  }));
-});
-
-afterEach(() => {
-  messageCalls.length = 0;
-  logCalls.length = 0;
-});
-
-const applyToast = (descriptor: PropertyDescriptor, key = "save") => {
-  return import("./decorators").then(({ Toast }) => {
-    Toast({ root: "user", duration: 5 })({}, key, descriptor);
-    return descriptor.value as (...args: unknown[]) => Promise<unknown>;
-  });
-};
-
-describe("Toast decorator", () => {
-  test("wraps async success with loading and success messages", async () => {
-    const descriptor: PropertyDescriptor = {
-      value: async (value: string) => `saved:${value}`,
-    };
-    const wrapped = await applyToast(descriptor);
-
-    await expect(wrapped("ok")).resolves.toBe("saved:ok");
-
-    expect(messageCalls).toEqual([
-      ["loading", "user.save-loading", { key: "save", duration: 5 }],
-      ["success", "user.save-success", { key: "save", duration: 5 }],
-    ]);
-  });
-
-  test("reports errors without rethrowing", async () => {
-    const descriptor: PropertyDescriptor = {
-      value: async () => {
-        throw new Error("boom");
-      },
-    };
-    const wrapped = await applyToast(descriptor, "remove");
-
-    await expect(wrapped()).resolves.toBeUndefined();
-
-    expect(messageCalls).toEqual([
-      ["loading", "user.remove-loading", { key: "remove", duration: 5 }],
-      ["error", "boom", { key: "remove", duration: 5 }],
-    ]);
-    expect(logCalls[0]).toEqual(["remove action error return: Error: boom"]);
-  });
-});

package/client/client.device.test.ts

@@ -1,181 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-
-const deviceState = {
-  platform: "web",
-  language: "en",
-  safeArea: { top: 11, bottom: 22 },
-  infoCalls: 0,
-  languageCalls: 0,
-  safeAreaCalls: 0,
-};
-const calls: unknown[] = [];
-
-const testCapacitor = () => ({
-  Plugins: {
-    Device: {
-      getInfo: async () => {
-        deviceState.infoCalls += 1;
-        return { platform: deviceState.platform, model: "test-device" };
-      },
-      getLanguageCode: async () => {
-        deviceState.languageCalls += 1;
-        return { value: deviceState.language };
-      },
-    },
-    Keyboard: {
-      show: async () => calls.push("keyboard.show"),
-      hide: async () => calls.push("keyboard.hide"),
-      addListener: async (event: string, callback: (info: { keyboardHeight: number }) => void) => {
-        calls.push(["keyboard.addListener", event]);
-        if (event === "keyboardWillShow") callback({ keyboardHeight: 320 });
-        if (event === "keyboardWillHide") callback({ keyboardHeight: 0 });
-      },
-      removeAllListeners: async () => calls.push("keyboard.removeAllListeners"),
-    },
-    Haptics: {
-      vibrate: async (options: { duration: number }) => calls.push(["haptics.vibrate", options]),
-      impact: async (options: { style: string }) => calls.push(["haptics.impact", options]),
-      selectionStart: async () => calls.push("haptics.selectionStart"),
-      selectionChanged: async () => calls.push("haptics.selectionChanged"),
-      selectionEnd: async () => calls.push("haptics.selectionEnd"),
-    },
-    SafeArea: {
-      getSafeAreaInsets: async () => {
-        deviceState.safeAreaCalls += 1;
-        return { insets: deviceState.safeArea };
-      },
-    },
-  },
-});
-
-const installWindow = (pathname = "/ko/home", options: { nativeTarget?: boolean } = {}) => {
-  const scrollCalls: unknown[] = [];
-  const capacitor = options.nativeTarget ? testCapacitor() : undefined;
-  Object.defineProperty(globalThis, "window", {
-    value: {
-      ...(options.nativeTarget ? { __AKAN_MOBILE_TARGET__: { name: "test" } } : {}),
-      ...(capacitor ? { Capacitor: capacitor } : {}),
-      location: { pathname },
-      scrollY: 42,
-      scrollTo: (options: unknown) => scrollCalls.push(options),
-    },
-    configurable: true,
-  });
-  Object.defineProperty(globalThis, "Capacitor", { value: capacitor, configurable: true });
-  return { scrollCalls };
-};
-
-afterEach(async () => {
-  const { Device } = await import("./device");
-  Device.instance = null;
-  deviceState.platform = "web";
-  deviceState.language = "en";
-  deviceState.safeArea = { top: 11, bottom: 22 };
-  deviceState.infoCalls = 0;
-  deviceState.languageCalls = 0;
-  deviceState.safeAreaCalls = 0;
-  calls.length = 0;
-  globalThis.__AKAN_CAPACITOR_IMPORTS__ = undefined;
-  delete process.env.AKAN_PUBLIC_RENDER_ENV;
-  Object.defineProperty(globalThis, "window", { value: undefined, configurable: true });
-  Object.defineProperty(globalThis, "Capacitor", { value: undefined, configurable: true });
-});
-
-describe("Device", () => {
-  test("regular web creates fallback device without loading Capacitor modules", async () => {
-    installWindow("/ko/profile");
-    const { Device } = await import("./device");
-
-    expect(() => Device.getDevice()).toThrow("Device is not loaded yet");
-    const device = await Device.load({ supportLanguages: ["en", "ko"] });
-    const second = await Device.load({ lang: "en", supportLanguages: ["en"] });
-
-    expect(device).toBe(second);
-    expect(device.lang).toBe("ko");
-    expect(device.info.platform).toBe("web");
-    expect(device.topSafeArea).toBe(0);
-    expect(device.bottomSafeArea).toBe(0);
-    expect(deviceState.infoCalls).toBe(0);
-    expect(deviceState.languageCalls).toBe(0);
-    expect(deviceState.safeAreaCalls).toBe(0);
-    expect(Device.getDevice()).toBe(device);
-  });
-
-  test("native target loads Capacitor info, URL language prefix, and safe-area insets", async () => {
-    installWindow("/ko/profile", { nativeTarget: true });
-    const { Device } = await import("./device");
-
-    const device = await Device.load({ supportLanguages: ["en", "ko"] });
-
-    expect(device.lang).toBe("ko");
-    expect(device.info.platform).toBe("web");
-    expect(device.topSafeArea).toBe(11);
-    expect(device.bottomSafeArea).toBe(22);
-    expect(deviceState.infoCalls).toBe(1);
-    expect(deviceState.languageCalls).toBe(1);
-    expect(deviceState.safeAreaCalls).toBe(1);
-  });
-
-  test("ssr render mode creates a web device without loading Capacitor modules", async () => {
-    process.env.AKAN_PUBLIC_RENDER_ENV = "ssr";
-    installWindow("/ko/profile");
-    const { Device } = await import("./device");
-
-    const device = await Device.load({ supportLanguages: ["en", "ko"] });
-
-    expect(device.lang).toBe("ko");
-    expect(device.info.platform).toBe("web");
-    expect(device.topSafeArea).toBe(0);
-    expect(device.bottomSafeArea).toBe(0);
-    expect(deviceState.infoCalls).toBe(0);
-    expect(deviceState.languageCalls).toBe(0);
-    expect(deviceState.safeAreaCalls).toBe(0);
-  });
-
-  test("web platform skips native keyboard and haptics but uses window scroll", async () => {
-    const { scrollCalls } = installWindow("/en/home");
-    const { Device } = await import("./device");
-    const device = await Device.load({ supportLanguages: ["en"] });
-
-    await device.showKeyboard();
-    await device.hideKeyboard();
-    device.listenKeyboardChanged(() => calls.push("keyboard.changed"));
-    device.unlistenKeyboardChanged();
-    expect(calls).toEqual([]);
-    expect(device.getScrollTop()).toBe(42);
-    device.setScrollTop(100);
-    expect(scrollCalls).toEqual([{ top: 100 }]);
-  });
-
-  test("native platform calls keyboard, haptics, and page content scrolling", async () => {
-    deviceState.platform = "ios";
-    installWindow("/en/home", { nativeTarget: true });
-    const { Device } = await import("./device");
-    const device = await Device.load({ supportLanguages: ["en"] });
-    const changed: number[] = [];
-    const scrollCalls: unknown[] = [];
-    device.setPageContentRef({
-      current: {
-        scrollTop: 55,
-        scrollTo: (options: unknown) => scrollCalls.push(options),
-      } as unknown as HTMLDivElement,
-    });
-
-    await device.showKeyboard();
-    await device.hideKeyboard();
-    device.listenKeyboardChanged((height) => changed.push(height));
-    device.unlistenKeyboardChanged();
-    await device.vibrate("light");
-    await device.vibrate(250);
-
-    expect(calls).toContain("keyboard.show");
-    expect(calls).toContain("keyboard.hide");
-    expect(calls).toContain("keyboard.removeAllListeners");
-    expect(calls).toContainEqual(["haptics.impact", { style: "LIGHT" }]);
-    expect(calls).toContainEqual(["haptics.vibrate", { duration: 250 }]);
-    expect(changed).toEqual([320, 0]);
-    expect(device.getScrollTop()).toBe(55);
-    device.setScrollTop(10);
-    expect(scrollCalls).toEqual([{ top: 10 }]);
-  });
-});

package/client/client.page.test.tsx

@@ -1,175 +0,0 @@
-import { afterEach, beforeAll, describe, expect, mock, test } from "bun:test";
-
-type EnvMode = "browser" | "server";
-
-const envState = {
-  mode: "browser" as EnvMode,
-};
-const requestState = {
-  headers: new Map<string, string>(),
-  request: undefined as Request | undefined,
-};
-const buildCalls: unknown[] = [];
-const serializedSignal = { service: { ping: { endpoint: {} } } };
-const generatedFetch = { setJwt: () => undefined, ping: () => "pong" };
-const generatedSig = { ping: "signal" };
-const dictionary = {
-  en: { user: { hello: { t: "Hello {name}" }, rich: { t: "Line{br}" } } },
-  ko: { user: { hello: { t: "안녕 {name}" } } },
-};
-
-beforeAll(() => {
-  mock.module("react/jsx-dev-runtime", () => ({
-    Fragment: ({ children }: { children: unknown }) => children,
-    jsxDEV: (type: unknown, props: Record<string, unknown>) => ({ type, props }),
-  }));
-  mock.module("react/jsx-runtime", () => ({
-    Fragment: ({ children }: { children: unknown }) => children,
-    jsx: (type: unknown, props: Record<string, unknown>) => ({ type, props }),
-    jsxs: (type: unknown, props: Record<string, unknown>) => ({ type, props }),
-  }));
-  mock.module("akanjs/base", () => ({
-    getEnv: () => ({
-      side: envState.mode === "server" ? "server" : "client",
-      renderMode: "csr",
-      appName: "test-app",
-      environment: "debug",
-    }),
-  }));
-  mock.module("akanjs/common", () => ({
-    Logger: { log: () => undefined, verbose: () => undefined, error: () => undefined },
-    parseAkanI18nEnv: () => ({ locales: ["en", "ko"], defaultLocale: "en" }),
-    parseBasePaths: (value?: string) => (value ? value.split(",").filter(Boolean) : []),
-    getBasePathFromPathname: () => null,
-    pathGet: (path: string, obj: Record<string, unknown>, separator = ".", fallback?: unknown) =>
-      path.split(separator).reduce<unknown>((acc, key) => {
-        if (!acc || typeof acc !== "object") return fallback;
-        return (acc as Record<string, unknown>)[key] ?? fallback;
-      }, obj),
-  }));
-  mock.module("akanjs/fetch", () => ({
-    FetchClient: {
-      build: (...args: unknown[]) => {
-        buildCalls.push(args);
-        return { fetch: generatedFetch, sig: generatedSig };
-      },
-    },
-    defaultAccount: { appName: "test-app", environment: "debug" },
-    requestStorage: { getStore: () => undefined },
-    getRequest: () => requestState.request,
-    headers: () => requestState.headers,
-  }));
-  mock.module("akanjs/signal", () => ({
-    Exception: class Exception extends Error {
-      constructor(
-        readonly statusCode: number,
-        message: string,
-        readonly details?: unknown,
-        readonly data?: unknown,
-      ) {
-        super(message);
-      }
-      toJSON() {
-        return {
-          error: this.message,
-          statusCode: this.statusCode,
-          ...(this.details !== undefined ? { details: this.details } : {}),
-          ...(this.data !== undefined ? { data: this.data } : {}),
-        };
-      }
-    },
-    getSerializedSignal: () => serializedSignal,
-  }));
-  mock.module("akanjs/dictionary", () => ({
-    getAllDictionary: () => dictionary,
-  }));
-  mock.module("akanjs/constant", () => ({
-    String: String,
-  }));
-});
-
-const installWindow = (pathname: string) => {
-  Object.defineProperty(globalThis, "window", {
-    value: { location: { pathname } },
-    configurable: true,
-  });
-};
-
-afterEach(() => {
-  envState.mode = "browser";
-  requestState.headers = new Map();
-  requestState.request = undefined;
-  buildCalls.length = 0;
-  Object.defineProperty(globalThis, "window", { value: undefined, configurable: true });
-});
-
-describe("makePageProto", () => {
-  test("derives browser locale and path from window location", async () => {
-    envState.mode = "browser";
-    installWindow("/ko/dashboard");
-    const { makePageProto } = await import("./makePageProto");
-    const { usePage } = makePageProto(dictionary);
-
-    const page = usePage();
-
-    expect(page.lang).toBe("ko");
-    expect(page.path).toBe("/dashboard");
-    expect(page.l("user.hello" as never, { name: "민" })).toBe("안녕 민");
-    expect(page.l._("user.missing")).toBe("user.missing");
-    expect(page.l.trans({ en: "English", ko: "Korean" })).toBe("Korean");
-  });
-
-  test("uses server headers first and falls back to request URL", async () => {
-    envState.mode = "server";
-    const { makePageProto } = await import("./makePageProto");
-    const { usePage, Err } = makePageProto(dictionary);
-
-    requestState.headers = new Map([
-      ["x-locale", "ko"],
-      ["x-path", "/from-header"],
-    ]);
-    expect(usePage()).toMatchObject({ lang: "ko", path: "/from-header" });
-
-    requestState.headers = new Map();
-    requestState.request = new Request("https://example.test/en/from-request?x=1");
-    expect(usePage()).toMatchObject({ lang: "en", path: "/from-request" });
-
-    const rich = usePage().l.rich("user.rich" as never);
-    expect(rich).toMatchObject({ props: { dangerouslySetInnerHTML: { __html: "Line<br />" } } });
-    expect(new Err("user.failure" as never).message).toBe("user.failure");
-    expect(new Err.NotFound("user.failure" as never).statusCode).toBe(404);
-    expect(
-      Err.fromJSON({
-        error: "user.failure",
-        statusCode: 409,
-        data: { id: "1" },
-        path: "/users",
-        timestamp: "2026-05-25T00:00:00.000Z",
-      }).toJSON(),
-    ).toMatchObject({
-      error: "user.failure",
-      statusCode: 409,
-      data: { id: "1" },
-      path: "/users",
-      timestamp: "2026-05-25T00:00:00.000Z",
-    });
-  });
-});
-
-describe("generated client glue", () => {
-  test("useClient.ts exposes registered client runtime proxies", async () => {
-    const { registerClientRuntime } = await import("./clientRuntime");
-    const { makePageProto } = await import("./makePageProto");
-    const pageProto = makePageProto(dictionary);
-    const runtimeFetch = Object.assign(() => "ok", generatedFetch);
-
-    registerClientRuntime({ ...pageProto, fetch: runtimeFetch, sig: generatedSig });
-    const client = await import("./useClient");
-
-    expect(client.fetch).toBeDefined();
-    expect(client.msg).toBeDefined();
-    expect(client.Err).toBeDefined();
-    expect((client.fetch.ping as () => string)()).toBe("pong");
-    expect(client.sig.ping).toBe("signal");
-  });
-});

package/client/client.pure.test.ts

@@ -1,146 +0,0 @@
-import { afterEach, beforeAll, describe, expect, mock, test } from "bun:test";
-import { createFont, Inter, Nanum_Gothic_Coding, Noto_Sans_KR, Roboto } from "./createFont";
-import { clearRscNavigationCache, navigateRsc } from "./rscNavigation";
-import { Translator } from "./translator";
-import {
-  clsx,
-  getFontFaces,
-  getFontFallbackName,
-  getFontStyles,
-  getFontVariableName,
-  getOptimizedFontSrc,
-  isFontOptimizationEnabled,
-  isFontPreloadEnabled,
-  loadFonts,
-  type ReactFont,
-} from "./types";
-
-beforeAll(() => {
-  mock.module("akanjs/common", () => ({
-    pathGet: (path: string, obj: Record<string, unknown>, separator = ".", fallback?: unknown) =>
-      path.split(separator).reduce<unknown>((acc, key) => {
-        if (!acc || typeof acc !== "object") return fallback;
-        return (acc as Record<string, unknown>)[key] ?? fallback;
-      }, obj),
-    Logger: { log: () => undefined, verbose: () => undefined, error: () => undefined },
-    parseAkanI18nEnv: () => ({ locales: ["en", "ko"], defaultLocale: "en" }),
-    parseBasePaths: (value?: string) => (value ? value.split(",").filter(Boolean) : []),
-    getBasePathFromPathname: () => null,
-  }));
-});
-
-afterEach(() => {
-  globalThis.__AKAN_RSC_CLEAR_CACHE__ = undefined;
-  globalThis.__AKAN_RSC_NAVIGATE__ = undefined;
-});
-
-describe("client pure exports and utilities", () => {
-  test("exports class composition and font helpers through the package surface", () => {
-    expect(clsx("base", false && "hidden", ["nested"], { active: true })).toBe("base nested active");
-    expect(typeof loadFonts).toBe("function");
-    expect(typeof getFontFaces).toBe("function");
-    expect(typeof Translator).toBe("function");
-  });
-
-  test("loads fonts with defaults and computes deterministic font metadata", () => {
-    const font: ReactFont = {
-      name: "Test Font",
-      paths: [
-        { src: "/fonts/test-400.woff2", weight: 400 },
-        {
-          src: "/fonts/test-700-italic.woff2",
-          weight: 700,
-          style: "italic",
-          declarations: [{ prop: "x", value: "y" }],
-        },
-      ],
-      styles: ["normal"],
-      display: "swap",
-    };
-    const [loaded] = loadFonts([font]);
-
-    expect(loaded?.subsets).toEqual(["latin"]);
-    expect(getFontVariableName(font)).toBe("--font-Test Font");
-    expect(getFontFallbackName(font)).toBe("Test Font fallback");
-    expect(getFontStyles(font)).toEqual(["normal"]);
-    expect(isFontOptimizationEnabled(font)).toBe(true);
-    expect(isFontPreloadEnabled(font)).toBe(true);
-    expect(isFontOptimizationEnabled({ ...font, optimize: false })).toBe(false);
-    expect(isFontPreloadEnabled({ ...font, preload: false })).toBe(false);
-    expect(getOptimizedFontSrc(font, font.paths[0])).toMatch(/^\/_akan\/fonts\/test-font-400-normal-[a-z0-9]+\.woff2$/);
-    expect(getOptimizedFontSrc(font, font.paths[0])).toBe(getOptimizedFontSrc({ ...font }, { ...font.paths[0] }));
-    expect(getFontFaces(font)).toEqual([
-      {
-        font,
-        path: font.paths[0],
-        src: "/fonts/test-400.woff2",
-        weight: 400,
-        style: "normal",
-        optimizedSrc: getOptimizedFontSrc(font, font.paths[0]),
-      },
-    ]);
-  });
-
-  test("createFont aliases are CSR-safe null shims", () => {
-    expect(createFont({ src: "ignored" })).toBeNull();
-    expect(Nanum_Gothic_Coding({})).toBeNull();
-    expect(Noto_Sans_KR({})).toBeNull();
-    expect(Inter({})).toBeNull();
-    expect(Roboto({})).toBeNull();
-  });
-
-  test("rsc navigation globals are optional and receive arguments", async () => {
-    const calls: unknown[] = [];
-
-    expect(clearRscNavigationCache()).toBeUndefined();
-    expect(navigateRsc("/missing")).toBeUndefined();
-
-    globalThis.__AKAN_RSC_CLEAR_CACHE__ = () => calls.push("clear");
-    globalThis.__AKAN_RSC_NAVIGATE__ = async (href, options) => {
-      calls.push({ href, options });
-    };
-
-    clearRscNavigationCache();
-    await navigateRsc("/next", { replace: true, scrollToTop: false });
-
-    expect(calls).toEqual(["clear", { href: "/next", options: { replace: true, scrollToTop: false } }]);
-  });
-});
-
-describe("Translator", () => {
-  test("merges dictionaries, translates nested paths, replaces params, and falls back to keys", async () => {
-    const translator = new Translator({
-      en: {
-        user: {
-          greeting: { t: "Hello {name}" },
-        },
-      },
-    });
-    new Translator({
-      en: {
-        user: {
-          nested: { title: { t: "Nested title" } },
-        },
-      },
-      ko: {
-        user: {
-          greeting: { t: "안녕 {name}" },
-        },
-      },
-    });
-
-    expect(translator.hasDictionary("en")).toBe(true);
-    expect(translator.translate("en", "user.greeting", { name: "Ada" })).toBe("Hello Ada");
-    expect(translator.translate("en", "user.nested.title")).toBe("Nested title");
-    expect(translator.translate("ko", "user.greeting", { name: "민" })).toBe("안녕 민");
-    expect(translator.translate("ja", "user.greeting")).toBe("user.greeting");
-    expect(translator.translate("en", "user.missing")).toBe("user.missing");
-    expect(await translator.getDictionary("en")).toMatchObject({
-      user: {
-        greeting: { t: "Hello {name}" },
-        nested: { title: { t: "Nested title" } },
-      },
-    });
-    await expect(translator.getDictionary("ja")).rejects.toThrow("Dictionary for language ja not found");
-  });
-});